1/*
2 This file is part of the WebKit open source project.
3 This file has been generated by generate-bindings.pl. DO NOT MODIFY!
4
5 This library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Library General Public
7 License as published by the Free Software Foundation; either
8 version 2 of the License, or (at your option) any later version.
9
10 This library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Library General Public License for more details.
14
15 You should have received a copy of the GNU Library General Public License
16 along with this library; see the file COPYING.LIB. If not, write to
17 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18 Boston, MA 02110-1301, USA.
19*/
20
21#include "config.h"
22#include "JSDOMWindow.h"
23
24#include "ActiveDOMObject.h"
25#include "DOMIsoSubspaces.h"
26#include "DOMPromiseProxy.h"
27#include "DOMWrapperWorld.h"
28#include "Document.h"
29#include "EventNames.h"
30#include "IDLTypes.h"
31#include "JSAbortController.h"
32#include "JSAbortSignal.h"
33#include "JSAbstractRange.h"
34#include "JSAnimationEffect.h"
35#include "JSAnimationEvent.h"
36#include "JSAnimationPlaybackEvent.h"
37#include "JSAnimationTimeline.h"
38#include "JSAttr.h"
39#include "JSBarProp.h"
40#include "JSBeforeLoadEvent.h"
41#include "JSBeforeUnloadEvent.h"
42#include "JSBlob.h"
43#include "JSByteLengthQueuingStrategy.h"
44#include "JSCDATASection.h"
45#include "JSCSSAnimation.h"
46#include "JSCSSConditionRule.h"
47#include "JSCSSCounterStyleRule.h"
48#include "JSCSSFontFaceRule.h"
49#include "JSCSSGroupingRule.h"
50#include "JSCSSImportRule.h"
51#include "JSCSSKeyframeRule.h"
52#include "JSCSSKeyframesRule.h"
53#include "JSCSSMediaRule.h"
54#include "JSCSSNamespaceRule.h"
55#include "JSCSSPageRule.h"
56#include "JSCSSRule.h"
57#include "JSCSSRuleList.h"
58#include "JSCSSStyleDeclaration.h"
59#include "JSCSSStyleRule.h"
60#include "JSCSSStyleSheet.h"
61#include "JSCSSSupportsRule.h"
62#include "JSCSSTransition.h"
63#include "JSCanvasGradient.h"
64#include "JSCanvasPattern.h"
65#include "JSCanvasRenderingContext2D.h"
66#include "JSCharacterData.h"
67#include "JSClipboard.h"
68#include "JSClipboardEvent.h"
69#include "JSClipboardItem.h"
70#include "JSCloseEvent.h"
71#include "JSComment.h"
72#include "JSCompositionEvent.h"
73#include "JSContactsManager.h"
74#include "JSCountQueuingStrategy.h"
75#include "JSCrypto.h"
76#include "JSCustomElementRegistry.h"
77#include "JSCustomEvent.h"
78#include "JSDOMApplicationCache.h"
79#include "JSDOMAttribute.h"
80#include "JSDOMBinding.h"
81#include "JSDOMBindingSecurity.h"
82#include "JSDOMBindingSecurityInlines.h"
83#include "JSDOMCSSNamespace.h"
84#include "JSDOMCache.h"
85#include "JSDOMCacheStorage.h"
86#include "JSDOMConstructorNotConstructable.h"
87#include "JSDOMConvertAny.h"
88#include "JSDOMConvertBase.h"
89#include "JSDOMConvertBoolean.h"
90#include "JSDOMConvertCallbacks.h"
91#include "JSDOMConvertInterface.h"
92#include "JSDOMConvertNullable.h"
93#include "JSDOMConvertNumbers.h"
94#include "JSDOMConvertObject.h"
95#include "JSDOMConvertPromise.h"
96#include "JSDOMConvertScheduledAction.h"
97#include "JSDOMConvertSequences.h"
98#include "JSDOMConvertStrings.h"
99#include "JSDOMConvertUnion.h"
100#include "JSDOMConvertVariadic.h"
101#include "JSDOMException.h"
102#include "JSDOMExceptionHandling.h"
103#include "JSDOMFileSystem.h"
104#include "JSDOMFormData.h"
105#include "JSDOMGlobalObject.h"
106#include "JSDOMGlobalObjectInlines.h"
107#include "JSDOMImplementation.h"
108#include "JSDOMMatrix.h"
109#include "JSDOMMatrixReadOnly.h"
110#include "JSDOMMimeType.h"
111#include "JSDOMMimeTypeArray.h"
112#include "JSDOMOperation.h"
113#include "JSDOMOperationReturningPromise.h"
114#include "JSDOMParser.h"
115#include "JSDOMPlugin.h"
116#include "JSDOMPluginArray.h"
117#include "JSDOMPoint.h"
118#include "JSDOMPointReadOnly.h"
119#include "JSDOMQuad.h"
120#include "JSDOMRect.h"
121#include "JSDOMRectList.h"
122#include "JSDOMRectReadOnly.h"
123#include "JSDOMSelection.h"
124#include "JSDOMStringList.h"
125#include "JSDOMStringMap.h"
126#include "JSDOMTokenList.h"
127#include "JSDOMURL.h"
128#include "JSDOMWindow.h"
129#include "JSDOMWrapperCache.h"
130#include "JSDataTransfer.h"
131#include "JSDataTransferItem.h"
132#include "JSDataTransferItemList.h"
133#include "JSDatabase.h"
134#include "JSDeprecatedCSSOMCounter.h"
135#include "JSDeprecatedCSSOMPrimitiveValue.h"
136#include "JSDeprecatedCSSOMRGBColor.h"
137#include "JSDeprecatedCSSOMRect.h"
138#include "JSDeprecatedCSSOMValue.h"
139#include "JSDeprecatedCSSOMValueList.h"
140#include "JSDocument.h"
141#include "JSDocumentFragment.h"
142#include "JSDocumentTimeline.h"
143#include "JSDocumentType.h"
144#include "JSDragEvent.h"
145#include "JSElement.h"
146#include "JSErrorEvent.h"
147#include "JSErrorHandler.h"
148#include "JSEvent.h"
149#include "JSEventListener.h"
150#include "JSEventSource.h"
151#include "JSEventTarget.h"
152#include "JSFetchHeaders.h"
153#include "JSFetchRequest.h"
154#include "JSFetchRequestInit.h"
155#include "JSFetchResponse.h"
156#include "JSFile.h"
157#include "JSFileList.h"
158#include "JSFileReader.h"
159#include "JSFileSystemDirectoryEntry.h"
160#include "JSFileSystemDirectoryReader.h"
161#include "JSFileSystemEntry.h"
162#include "JSFileSystemFileEntry.h"
163#include "JSFocusEvent.h"
164#include "JSFontFace.h"
165#include "JSFontFaceSet.h"
166#include "JSHTMLAllCollection.h"
167#include "JSHTMLAnchorElement.h"
168#include "JSHTMLAreaElement.h"
169#include "JSHTMLBRElement.h"
170#include "JSHTMLBaseElement.h"
171#include "JSHTMLBodyElement.h"
172#include "JSHTMLButtonElement.h"
173#include "JSHTMLCanvasElement.h"
174#include "JSHTMLCollection.h"
175#include "JSHTMLDListElement.h"
176#include "JSHTMLDataElement.h"
177#include "JSHTMLDetailsElement.h"
178#include "JSHTMLDialogElement.h"
179#include "JSHTMLDirectoryElement.h"
180#include "JSHTMLDivElement.h"
181#include "JSHTMLDocument.h"
182#include "JSHTMLElement.h"
183#include "JSHTMLEmbedElement.h"
184#include "JSHTMLFieldSetElement.h"
185#include "JSHTMLFontElement.h"
186#include "JSHTMLFormControlsCollection.h"
187#include "JSHTMLFormElement.h"
188#include "JSHTMLFrameElement.h"
189#include "JSHTMLFrameSetElement.h"
190#include "JSHTMLHRElement.h"
191#include "JSHTMLHeadElement.h"
192#include "JSHTMLHeadingElement.h"
193#include "JSHTMLHtmlElement.h"
194#include "JSHTMLIFrameElement.h"
195#include "JSHTMLImageElement.h"
196#include "JSHTMLInputElement.h"
197#include "JSHTMLKeygenElement.h"
198#include "JSHTMLLIElement.h"
199#include "JSHTMLLabelElement.h"
200#include "JSHTMLLegendElement.h"
201#include "JSHTMLLinkElement.h"
202#include "JSHTMLMapElement.h"
203#include "JSHTMLMarqueeElement.h"
204#include "JSHTMLMenuElement.h"
205#include "JSHTMLMenuItemElement.h"
206#include "JSHTMLMetaElement.h"
207#include "JSHTMLMeterElement.h"
208#include "JSHTMLModElement.h"
209#include "JSHTMLOListElement.h"
210#include "JSHTMLObjectElement.h"
211#include "JSHTMLOptGroupElement.h"
212#include "JSHTMLOptionElement.h"
213#include "JSHTMLOptionsCollection.h"
214#include "JSHTMLOutputElement.h"
215#include "JSHTMLParagraphElement.h"
216#include "JSHTMLParamElement.h"
217#include "JSHTMLPictureElement.h"
218#include "JSHTMLPreElement.h"
219#include "JSHTMLProgressElement.h"
220#include "JSHTMLQuoteElement.h"
221#include "JSHTMLScriptElement.h"
222#include "JSHTMLSelectElement.h"
223#include "JSHTMLSlotElement.h"
224#include "JSHTMLSourceElement.h"
225#include "JSHTMLSpanElement.h"
226#include "JSHTMLStyleElement.h"
227#include "JSHTMLTableCaptionElement.h"
228#include "JSHTMLTableCellElement.h"
229#include "JSHTMLTableColElement.h"
230#include "JSHTMLTableElement.h"
231#include "JSHTMLTableRowElement.h"
232#include "JSHTMLTableSectionElement.h"
233#include "JSHTMLTemplateElement.h"
234#include "JSHTMLTextAreaElement.h"
235#include "JSHTMLTimeElement.h"
236#include "JSHTMLTitleElement.h"
237#include "JSHTMLUListElement.h"
238#include "JSHTMLUnknownElement.h"
239#include "JSHTMLVideoElement.h"
240#include "JSHashChangeEvent.h"
241#include "JSHighlight.h"
242#include "JSHighlightRegister.h"
243#include "JSHistory.h"
244#include "JSIDBCursor.h"
245#include "JSIDBCursorWithValue.h"
246#include "JSIDBDatabase.h"
247#include "JSIDBFactory.h"
248#include "JSIDBIndex.h"
249#include "JSIDBKeyRange.h"
250#include "JSIDBObjectStore.h"
251#include "JSIDBOpenDBRequest.h"
252#include "JSIDBRequest.h"
253#include "JSIDBTransaction.h"
254#include "JSIDBVersionChangeEvent.h"
255#include "JSIdleDeadline.h"
256#include "JSIdleRequestCallback.h"
257#include "JSIdleRequestOptions.h"
258#include "JSImageBitmap.h"
259#include "JSImageBitmapOptions.h"
260#include "JSImageBitmapRenderingContext.h"
261#include "JSImageData.h"
262#include "JSInputEvent.h"
263#include "JSKeyboardEvent.h"
264#include "JSKeyframeEffect.h"
265#include "JSLocation.h"
266#include "JSMediaCapabilities.h"
267#include "JSMediaList.h"
268#include "JSMediaQueryList.h"
269#include "JSMediaQueryListEvent.h"
270#include "JSMessageEvent.h"
271#include "JSMessagePort.h"
272#include "JSMouseEvent.h"
273#include "JSMutationEvent.h"
274#include "JSMutationObserver.h"
275#include "JSMutationRecord.h"
276#include "JSNamedNodeMap.h"
277#include "JSNavigator.h"
278#include "JSNode.h"
279#include "JSNodeFilter.h"
280#include "JSNodeIterator.h"
281#include "JSNodeList.h"
282#include "JSOverflowEvent.h"
283#include "JSPageTransitionEvent.h"
284#include "JSPath2D.h"
285#include "JSPerformance.h"
286#include "JSPerformanceEntry.h"
287#include "JSPerformanceMark.h"
288#include "JSPerformanceMeasure.h"
289#include "JSPerformanceNavigation.h"
290#include "JSPerformanceNavigationTiming.h"
291#include "JSPerformanceObserver.h"
292#include "JSPerformanceObserverEntryList.h"
293#include "JSPerformancePaintTiming.h"
294#include "JSPerformanceResourceTiming.h"
295#include "JSPerformanceServerTiming.h"
296#include "JSPerformanceTiming.h"
297#include "JSPointerEvent.h"
298#include "JSPopStateEvent.h"
299#include "JSProcessingInstruction.h"
300#include "JSProgressEvent.h"
301#include "JSPromiseRejectionEvent.h"
302#include "JSRadioNodeList.h"
303#include "JSRange.h"
304#include "JSReadableByteStreamController.h"
305#include "JSReadableStream.h"
306#include "JSReadableStreamBYOBReader.h"
307#include "JSReadableStreamBYOBRequest.h"
308#include "JSReadableStreamDefaultController.h"
309#include "JSReadableStreamDefaultReader.h"
310#include "JSRequestAnimationFrameCallback.h"
311#include "JSSQLError.h"
312#include "JSSQLResultSet.h"
313#include "JSSQLResultSetRowList.h"
314#include "JSSQLTransaction.h"
315#include "JSSVGAElement.h"
316#include "JSSVGAltGlyphDefElement.h"
317#include "JSSVGAltGlyphElement.h"
318#include "JSSVGAltGlyphItemElement.h"
319#include "JSSVGAngle.h"
320#include "JSSVGAnimateColorElement.h"
321#include "JSSVGAnimateElement.h"
322#include "JSSVGAnimateMotionElement.h"
323#include "JSSVGAnimateTransformElement.h"
324#include "JSSVGAnimatedAngle.h"
325#include "JSSVGAnimatedBoolean.h"
326#include "JSSVGAnimatedEnumeration.h"
327#include "JSSVGAnimatedInteger.h"
328#include "JSSVGAnimatedLength.h"
329#include "JSSVGAnimatedLengthList.h"
330#include "JSSVGAnimatedNumber.h"
331#include "JSSVGAnimatedNumberList.h"
332#include "JSSVGAnimatedPreserveAspectRatio.h"
333#include "JSSVGAnimatedRect.h"
334#include "JSSVGAnimatedString.h"
335#include "JSSVGAnimatedTransformList.h"
336#include "JSSVGAnimationElement.h"
337#include "JSSVGCircleElement.h"
338#include "JSSVGClipPathElement.h"
339#include "JSSVGComponentTransferFunctionElement.h"
340#include "JSSVGCursorElement.h"
341#include "JSSVGDefsElement.h"
342#include "JSSVGDescElement.h"
343#include "JSSVGElement.h"
344#include "JSSVGEllipseElement.h"
345#include "JSSVGFEBlendElement.h"
346#include "JSSVGFEColorMatrixElement.h"
347#include "JSSVGFEComponentTransferElement.h"
348#include "JSSVGFECompositeElement.h"
349#include "JSSVGFEConvolveMatrixElement.h"
350#include "JSSVGFEDiffuseLightingElement.h"
351#include "JSSVGFEDisplacementMapElement.h"
352#include "JSSVGFEDistantLightElement.h"
353#include "JSSVGFEDropShadowElement.h"
354#include "JSSVGFEFloodElement.h"
355#include "JSSVGFEFuncAElement.h"
356#include "JSSVGFEFuncBElement.h"
357#include "JSSVGFEFuncGElement.h"
358#include "JSSVGFEFuncRElement.h"
359#include "JSSVGFEGaussianBlurElement.h"
360#include "JSSVGFEImageElement.h"
361#include "JSSVGFEMergeElement.h"
362#include "JSSVGFEMergeNodeElement.h"
363#include "JSSVGFEMorphologyElement.h"
364#include "JSSVGFEOffsetElement.h"
365#include "JSSVGFEPointLightElement.h"
366#include "JSSVGFESpecularLightingElement.h"
367#include "JSSVGFESpotLightElement.h"
368#include "JSSVGFETileElement.h"
369#include "JSSVGFETurbulenceElement.h"
370#include "JSSVGFilterElement.h"
371#include "JSSVGFontElement.h"
372#include "JSSVGFontFaceElement.h"
373#include "JSSVGFontFaceFormatElement.h"
374#include "JSSVGFontFaceNameElement.h"
375#include "JSSVGFontFaceSrcElement.h"
376#include "JSSVGFontFaceUriElement.h"
377#include "JSSVGForeignObjectElement.h"
378#include "JSSVGGElement.h"
379#include "JSSVGGeometryElement.h"
380#include "JSSVGGlyphElement.h"
381#include "JSSVGGlyphRefElement.h"
382#include "JSSVGGradientElement.h"
383#include "JSSVGGraphicsElement.h"
384#include "JSSVGHKernElement.h"
385#include "JSSVGImageElement.h"
386#include "JSSVGLength.h"
387#include "JSSVGLengthList.h"
388#include "JSSVGLineElement.h"
389#include "JSSVGLinearGradientElement.h"
390#include "JSSVGMPathElement.h"
391#include "JSSVGMarkerElement.h"
392#include "JSSVGMaskElement.h"
393#include "JSSVGMatrix.h"
394#include "JSSVGMetadataElement.h"
395#include "JSSVGMissingGlyphElement.h"
396#include "JSSVGNumber.h"
397#include "JSSVGNumberList.h"
398#include "JSSVGPathElement.h"
399#include "JSSVGPathSeg.h"
400#include "JSSVGPathSegArcAbs.h"
401#include "JSSVGPathSegArcRel.h"
402#include "JSSVGPathSegClosePath.h"
403#include "JSSVGPathSegCurvetoCubicAbs.h"
404#include "JSSVGPathSegCurvetoCubicRel.h"
405#include "JSSVGPathSegCurvetoCubicSmoothAbs.h"
406#include "JSSVGPathSegCurvetoCubicSmoothRel.h"
407#include "JSSVGPathSegCurvetoQuadraticAbs.h"
408#include "JSSVGPathSegCurvetoQuadraticRel.h"
409#include "JSSVGPathSegCurvetoQuadraticSmoothAbs.h"
410#include "JSSVGPathSegCurvetoQuadraticSmoothRel.h"
411#include "JSSVGPathSegLinetoAbs.h"
412#include "JSSVGPathSegLinetoHorizontalAbs.h"
413#include "JSSVGPathSegLinetoHorizontalRel.h"
414#include "JSSVGPathSegLinetoRel.h"
415#include "JSSVGPathSegLinetoVerticalAbs.h"
416#include "JSSVGPathSegLinetoVerticalRel.h"
417#include "JSSVGPathSegList.h"
418#include "JSSVGPathSegMovetoAbs.h"
419#include "JSSVGPathSegMovetoRel.h"
420#include "JSSVGPatternElement.h"
421#include "JSSVGPoint.h"
422#include "JSSVGPointList.h"
423#include "JSSVGPolygonElement.h"
424#include "JSSVGPolylineElement.h"
425#include "JSSVGPreserveAspectRatio.h"
426#include "JSSVGRadialGradientElement.h"
427#include "JSSVGRect.h"
428#include "JSSVGRectElement.h"
429#include "JSSVGRenderingIntent.h"
430#include "JSSVGSVGElement.h"
431#include "JSSVGScriptElement.h"
432#include "JSSVGSetElement.h"
433#include "JSSVGStopElement.h"
434#include "JSSVGStringList.h"
435#include "JSSVGStyleElement.h"
436#include "JSSVGSwitchElement.h"
437#include "JSSVGSymbolElement.h"
438#include "JSSVGTRefElement.h"
439#include "JSSVGTSpanElement.h"
440#include "JSSVGTextContentElement.h"
441#include "JSSVGTextElement.h"
442#include "JSSVGTextPathElement.h"
443#include "JSSVGTextPositioningElement.h"
444#include "JSSVGTitleElement.h"
445#include "JSSVGTransform.h"
446#include "JSSVGTransformList.h"
447#include "JSSVGUnitTypes.h"
448#include "JSSVGUseElement.h"
449#include "JSSVGVKernElement.h"
450#include "JSSVGViewElement.h"
451#include "JSSVGViewSpec.h"
452#include "JSSVGZoomEvent.h"
453#include "JSScreen.h"
454#include "JSScrollToOptions.h"
455#include "JSSecurityPolicyViolationEvent.h"
456#include "JSShadowRoot.h"
457#include "JSSpeechRecognition.h"
458#include "JSSpeechRecognitionAlternative.h"
459#include "JSSpeechRecognitionErrorEvent.h"
460#include "JSSpeechRecognitionEvent.h"
461#include "JSSpeechRecognitionResult.h"
462#include "JSSpeechRecognitionResultList.h"
463#include "JSStaticRange.h"
464#include "JSStorage.h"
465#include "JSStorageEvent.h"
466#include "JSStyleMedia.h"
467#include "JSStyleSheet.h"
468#include "JSStyleSheetList.h"
469#include "JSText.h"
470#include "JSTextDecoder.h"
471#include "JSTextDecoderStream.h"
472#include "JSTextDecoderStreamDecoder.h"
473#include "JSTextEncoder.h"
474#include "JSTextEncoderStream.h"
475#include "JSTextEncoderStreamEncoder.h"
476#include "JSTextEvent.h"
477#include "JSTextMetrics.h"
478#include "JSTransformStream.h"
479#include "JSTransformStreamDefaultController.h"
480#include "JSTransitionEvent.h"
481#include "JSTreeWalker.h"
482#include "JSTypedOMCSSImageValue.h"
483#include "JSUIEvent.h"
484#include "JSURLSearchParams.h"
485#include "JSUndoItem.h"
486#include "JSUndoManager.h"
487#include "JSValidityState.h"
488#include "JSVisualViewport.h"
489#include "JSWebAnimation.h"
490#include "JSWebKitAnimationEvent.h"
491#include "JSWebKitPoint.h"
492#include "JSWebKitTransitionEvent.h"
493#include "JSWebSocket.h"
494#include "JSWheelEvent.h"
495#include "JSWindowProxy.h"
496#include "JSWorker.h"
497#include "JSWorklet.h"
498#include "JSWritableStream.h"
499#include "JSWritableStreamDefaultController.h"
500#include "JSWritableStreamDefaultWriter.h"
501#include "JSXMLDocument.h"
502#include "JSXMLHttpRequest.h"
503#include "JSXMLHttpRequestEventTarget.h"
504#include "JSXMLHttpRequestProgressEvent.h"
505#include "JSXMLHttpRequestUpload.h"
506#include "JSXMLSerializer.h"
507#include "JSXPathEvaluator.h"
508#include "JSXPathExpression.h"
509#include "JSXPathResult.h"
510#include "Quirks.h"
511#include "RuntimeEnabledFeatures.h"
512#include "ScriptExecutionContext.h"
513#include "WebCoreJSClientData.h"
514#include "WindowOrWorkerGlobalScopeCaches.h"
515#include "WindowOrWorkerGlobalScopeFetch.h"
516#include "WindowOrWorkerGlobalScopeIndexedDatabase.h"
517#include <JavaScriptCore/JSArray.h>
518#include <JavaScriptCore/JSCInlines.h>
519#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>
520#include <JavaScriptCore/SlotVisitorMacros.h>
521#include <JavaScriptCore/SubspaceInlines.h>
522#include <wtf/GetPtr.h>
523#include <wtf/PointerPreparations.h>
524#include <wtf/Variant.h>
525
526#if ENABLE(APPLE_PAY)
527#include "JSApplePayError.h"
528#include "JSApplePaySession.h"
529#include "JSApplePaySetup.h"
530#include "JSApplePaySetupFeature.h"
531#endif
532
533#if ENABLE(ATTACHMENT_ELEMENT)
534#include "JSHTMLAttachmentElement.h"
535#endif
536
537#if ENABLE(CHANNEL_MESSAGING)
538#include "JSMessageChannel.h"
539#endif
540
541#if ENABLE(CSS_TYPED_OM)
542#include "JSStylePropertyMap.h"
543#include "JSStylePropertyMapReadOnly.h"
544#include "JSTypedOMCSSNumericValue.h"
545#include "JSTypedOMCSSStyleValue.h"
546#include "JSTypedOMCSSUnitValue.h"
547#include "JSTypedOMCSSUnparsedValue.h"
548#endif
549
550#if ENABLE(DATALIST_ELEMENT)
551#include "JSHTMLDataListElement.h"
552#endif
553
554#if ENABLE(DEVICE_ORIENTATION)
555#include "JSDeviceMotionEvent.h"
556#include "JSDeviceOrientationEvent.h"
557#endif
558
559#if ENABLE(ENCRYPTED_MEDIA)
560#include "JSMediaEncryptedEvent.h"
561#include "JSMediaKeyMessageEvent.h"
562#include "JSMediaKeySession.h"
563#include "JSMediaKeyStatusMap.h"
564#include "JSMediaKeySystemAccess.h"
565#include "JSMediaKeys.h"
566#endif
567
568#if ENABLE(GAMEPAD)
569#include "JSGamepad.h"
570#include "JSGamepadButton.h"
571#include "JSGamepadEvent.h"
572#endif
573
574#if ENABLE(GEOLOCATION)
575#include "JSGeolocation.h"
576#include "JSGeolocationCoordinates.h"
577#include "JSGeolocationPosition.h"
578#include "JSGeolocationPositionError.h"
579#endif
580
581#if ENABLE(INTERSECTION_OBSERVER)
582#include "JSIntersectionObserver.h"
583#include "JSIntersectionObserverEntry.h"
584#endif
585
586#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
587#include "JSWebKitMediaKeyError.h"
588#include "JSWebKitMediaKeyMessageEvent.h"
589#include "JSWebKitMediaKeyNeededEvent.h"
590#include "JSWebKitMediaKeySession.h"
591#include "JSWebKitMediaKeys.h"
592#endif
593
594#if ENABLE(MATHML)
595#include "JSMathMLElement.h"
596#include "JSMathMLMathElement.h"
597#endif
598
599#if ENABLE(MEDIA_SESSION)
600#include "JSMediaMetadata.h"
601#include "JSMediaSession.h"
602#endif
603
604#if ENABLE(MEDIA_SESSION_COORDINATOR)
605#include "JSMediaSessionCoordinator.h"
606#endif
607
608#if ENABLE(MEDIA_SOURCE)
609#include "JSMediaSource.h"
610#include "JSSourceBuffer.h"
611#include "JSSourceBufferList.h"
612#endif
613
614#if ENABLE(MEDIA_STREAM)
615#include "JSBlobEvent.h"
616#include "JSCanvasCaptureMediaStreamTrack.h"
617#include "JSMediaDeviceInfo.h"
618#include "JSMediaDevices.h"
619#include "JSMediaRecorder.h"
620#include "JSMediaRecorderErrorEvent.h"
621#include "JSMediaStream.h"
622#include "JSMediaStreamTrack.h"
623#include "JSMediaStreamTrackEvent.h"
624#include "JSOverconstrainedError.h"
625#include "JSOverconstrainedErrorEvent.h"
626#endif
627
628#if ENABLE(MEDIA_STREAM) && ENABLE(WEB_AUDIO)
629#include "JSMediaStreamAudioDestinationNode.h"
630#include "JSMediaStreamAudioSourceNode.h"
631#endif
632
633#if ENABLE(MODEL_ELEMENT)
634#include "JSHTMLModelElement.h"
635#endif
636
637#if ENABLE(NOTIFICATIONS)
638#include "JSNotification.h"
639#endif
640
641#if ENABLE(OFFSCREEN_CANVAS)
642#include "JSOffscreenCanvas.h"
643#include "JSOffscreenCanvasRenderingContext2D.h"
644#endif
645
646#if ENABLE(PAYMENT_REQUEST)
647#include "JSMerchantValidationEvent.h"
648#include "JSPaymentAddress.h"
649#include "JSPaymentMethodChangeEvent.h"
650#include "JSPaymentRequest.h"
651#include "JSPaymentRequestUpdateEvent.h"
652#include "JSPaymentResponse.h"
653#endif
654
655#if ENABLE(PICTURE_IN_PICTURE_API)
656#include "JSEnterPictureInPictureEvent.h"
657#include "JSPictureInPictureWindow.h"
658#endif
659
660#if ENABLE(RESIZE_OBSERVER)
661#include "JSResizeObserver.h"
662#include "JSResizeObserverEntry.h"
663#endif
664
665#if ENABLE(SERVICE_WORKER)
666#include "JSServiceWorker.h"
667#include "JSServiceWorkerContainer.h"
668#include "JSServiceWorkerRegistration.h"
669#endif
670
671#if ENABLE(SPEECH_SYNTHESIS)
672#include "DOMWindowSpeechSynthesis.h"
673#include "JSSpeechSynthesis.h"
674#include "JSSpeechSynthesisEvent.h"
675#include "JSSpeechSynthesisUtterance.h"
676#endif
677
678#if ENABLE(TOUCH_EVENTS)
679#include "JSTouch.h"
680#include "JSTouchEvent.h"
681#include "JSTouchList.h"
682#endif
683
684#if ENABLE(USER_MESSAGE_HANDLERS)
685#include "JSUserMessageHandler.h"
686#include "JSUserMessageHandlersNamespace.h"
687#include "JSWebKitNamespace.h"
688#endif
689
690#if ENABLE(VIDEO)
691#include "JSAudioTrack.h"
692#include "JSAudioTrackList.h"
693#include "JSDataCue.h"
694#include "JSHTMLAudioElement.h"
695#include "JSHTMLMediaElement.h"
696#include "JSHTMLTrackElement.h"
697#include "JSMediaController.h"
698#include "JSMediaError.h"
699#include "JSTextTrack.h"
700#include "JSTextTrackCue.h"
701#include "JSTextTrackCueList.h"
702#include "JSTextTrackList.h"
703#include "JSTimeRanges.h"
704#include "JSTrackEvent.h"
705#include "JSVTTCue.h"
706#include "JSVTTRegion.h"
707#include "JSVideoTrack.h"
708#include "JSVideoTrackList.h"
709#endif
710
711#if ENABLE(VIDEO) && ENABLE(WEB_AUDIO)
712#include "JSMediaElementAudioSourceNode.h"
713#endif
714
715#if ENABLE(WEBGL)
716#include "JSWebGLActiveInfo.h"
717#include "JSWebGLBuffer.h"
718#include "JSWebGLContextEvent.h"
719#include "JSWebGLFramebuffer.h"
720#include "JSWebGLProgram.h"
721#include "JSWebGLQuery.h"
722#include "JSWebGLRenderbuffer.h"
723#include "JSWebGLRenderingContext.h"
724#include "JSWebGLSampler.h"
725#include "JSWebGLShader.h"
726#include "JSWebGLShaderPrecisionFormat.h"
727#include "JSWebGLSync.h"
728#include "JSWebGLTexture.h"
729#include "JSWebGLUniformLocation.h"
730#endif
731
732#if ENABLE(WEBGL2)
733#include "JSWebGL2RenderingContext.h"
734#include "JSWebGLTransformFeedback.h"
735#include "JSWebGLVertexArrayObject.h"
736#endif
737
738#if ENABLE(WEBGPU)
739#include "JSGPUBufferUsage.h"
740#include "JSGPUCanvasContext.h"
741#include "JSGPUColorWrite.h"
742#include "JSGPUOutOfMemoryError.h"
743#include "JSGPUShaderStage.h"
744#include "JSGPUTextureUsage.h"
745#include "JSGPUUncapturedErrorEvent.h"
746#include "JSGPUValidationError.h"
747#include "JSWebGPU.h"
748#include "JSWebGPUAdapter.h"
749#include "JSWebGPUBindGroup.h"
750#include "JSWebGPUBindGroupLayout.h"
751#include "JSWebGPUBuffer.h"
752#include "JSWebGPUCommandBuffer.h"
753#include "JSWebGPUCommandEncoder.h"
754#include "JSWebGPUComputePassEncoder.h"
755#include "JSWebGPUComputePipeline.h"
756#include "JSWebGPUDevice.h"
757#include "JSWebGPUPipelineLayout.h"
758#include "JSWebGPUProgrammablePassEncoder.h"
759#include "JSWebGPUQueue.h"
760#include "JSWebGPURenderPassEncoder.h"
761#include "JSWebGPURenderPipeline.h"
762#include "JSWebGPUSampler.h"
763#include "JSWebGPUShaderModule.h"
764#include "JSWebGPUSwapChain.h"
765#include "JSWebGPUTexture.h"
766#include "JSWebGPUTextureView.h"
767#endif
768
769#if ENABLE(WEBXR)
770#include "JSWebXRBoundedReferenceSpace.h"
771#include "JSWebXRFrame.h"
772#include "JSWebXRInputSource.h"
773#include "JSWebXRInputSourceArray.h"
774#include "JSWebXRLayer.h"
775#include "JSWebXRPose.h"
776#include "JSWebXRReferenceSpace.h"
777#include "JSWebXRRenderState.h"
778#include "JSWebXRRigidTransform.h"
779#include "JSWebXRSession.h"
780#include "JSWebXRSpace.h"
781#include "JSWebXRSystem.h"
782#include "JSWebXRView.h"
783#include "JSWebXRViewerPose.h"
784#include "JSWebXRViewport.h"
785#include "JSWebXRWebGLLayer.h"
786#include "JSXRInputSourceEvent.h"
787#include "JSXRInputSourcesChangeEvent.h"
788#include "JSXRReferenceSpaceEvent.h"
789#include "JSXRSessionEvent.h"
790#endif
791
792#if ENABLE(WEB_AUDIO)
793#include "JSAnalyserNode.h"
794#include "JSAudioBuffer.h"
795#include "JSAudioBufferSourceNode.h"
796#include "JSAudioContext.h"
797#include "JSAudioDestinationNode.h"
798#include "JSAudioListener.h"
799#include "JSAudioNode.h"
800#include "JSAudioParam.h"
801#include "JSAudioParamMap.h"
802#include "JSAudioProcessingEvent.h"
803#include "JSAudioScheduledSourceNode.h"
804#include "JSAudioWorklet.h"
805#include "JSAudioWorkletNode.h"
806#include "JSBaseAudioContext.h"
807#include "JSBiquadFilterNode.h"
808#include "JSChannelMergerNode.h"
809#include "JSChannelSplitterNode.h"
810#include "JSConstantSourceNode.h"
811#include "JSConvolverNode.h"
812#include "JSDelayNode.h"
813#include "JSDynamicsCompressorNode.h"
814#include "JSGainNode.h"
815#include "JSIIRFilterNode.h"
816#include "JSOfflineAudioCompletionEvent.h"
817#include "JSOfflineAudioContext.h"
818#include "JSOscillatorNode.h"
819#include "JSPannerNode.h"
820#include "JSPeriodicWave.h"
821#include "JSScriptProcessorNode.h"
822#include "JSStereoPannerNode.h"
823#include "JSWaveShaperNode.h"
824#endif
825
826#if ENABLE(WEB_AUTHN)
827#include "JSAuthenticatorAssertionResponse.h"
828#include "JSAuthenticatorAttestationResponse.h"
829#include "JSAuthenticatorResponse.h"
830#include "JSBasicCredential.h"
831#include "JSCredentialsContainer.h"
832#include "JSPublicKeyCredential.h"
833#endif
834
835#if ENABLE(WEB_CRYPTO)
836#include "JSCryptoKey.h"
837#include "JSSubtleCrypto.h"
838#endif
839
840#if ENABLE(WEB_RTC)
841#include "JSRTCCertificate.h"
842#include "JSRTCDTMFSender.h"
843#include "JSRTCDTMFToneChangeEvent.h"
844#include "JSRTCDataChannel.h"
845#include "JSRTCDataChannelEvent.h"
846#include "JSRTCIceCandidate.h"
847#include "JSRTCIceTransport.h"
848#include "JSRTCPeerConnection.h"
849#include "JSRTCPeerConnectionIceErrorEvent.h"
850#include "JSRTCPeerConnectionIceEvent.h"
851#include "JSRTCRtpReceiver.h"
852#include "JSRTCRtpSFrameTransform.h"
853#include "JSRTCRtpScriptTransform.h"
854#include "JSRTCRtpSender.h"
855#include "JSRTCRtpTransceiver.h"
856#include "JSRTCSessionDescription.h"
857#include "JSRTCStatsReport.h"
858#include "JSRTCTrackEvent.h"
859#endif
860
861#if ENABLE(WIRELESS_PLAYBACK_TARGET)
862#include "JSRemotePlayback.h"
863#include "JSWebKitPlaybackTargetAvailabilityEvent.h"
864#endif
865
866#if ENABLE(XSLT)
867#include "JSXSLTProcessor.h"
868#endif
869
870
871namespace WebCore {
872using namespace JSC;
873
874template<> WindowPostMessageOptions convertDictionary<WindowPostMessageOptions>(JSGlobalObject& lexicalGlobalObject, JSValue value)
875{
876 VM& vm = JSC::getVM(&lexicalGlobalObject);
877 auto throwScope = DECLARE_THROW_SCOPE(vm);
878 bool isNullOrUndefined = value.isUndefinedOrNull();
879 auto* object = isNullOrUndefined ? nullptr : value.getObject();
880 if (UNLIKELY(!isNullOrUndefined && !object)) {
881 throwTypeError(&lexicalGlobalObject, throwScope);
882 return { };
883 }
884 WindowPostMessageOptions result;
885 JSValue transferValue;
886 if (isNullOrUndefined)
887 transferValue = jsUndefined();
888 else {
889 transferValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "transfer"));
890 RETURN_IF_EXCEPTION(throwScope, { });
891 }
892 if (!transferValue.isUndefined()) {
893 result.transfer = convert<IDLSequence<IDLObject>>(lexicalGlobalObject, transferValue);
894 RETURN_IF_EXCEPTION(throwScope, { });
895 } else
896 result.transfer = Converter<IDLSequence<IDLObject>>::ReturnType{ };
897 JSValue targetOriginValue;
898 if (isNullOrUndefined)
899 targetOriginValue = jsUndefined();
900 else {
901 targetOriginValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "targetOrigin"));
902 RETURN_IF_EXCEPTION(throwScope, { });
903 }
904 if (!targetOriginValue.isUndefined()) {
905 result.targetOrigin = convert<IDLUSVString>(lexicalGlobalObject, targetOriginValue);
906 RETURN_IF_EXCEPTION(throwScope, { });
907 } else
908 result.targetOrigin = "/"_s;
909 return result;
910}
911
912// Functions
913
914static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_close);
915static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_stop);
916static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_focus);
917static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_blur);
918static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_open);
919static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_alert);
920static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_confirm);
921static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_prompt);
922static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_print);
923static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_postMessage);
924static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_captureEvents);
925static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_releaseEvents);
926static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_find);
927static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_webkitRequestAnimationFrame);
928static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_webkitCancelAnimationFrame);
929static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_webkitCancelRequestAnimationFrame);
930static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_showModalDialog);
931static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_getMatchedCSSRules);
932static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_webkitConvertPointFromPageToNode);
933static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_webkitConvertPointFromNodeToPage);
934static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_collectMatchingElementsInFlatTree);
935static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_matchingElementInFlatTree);
936static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_requestAnimationFrame);
937static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_cancelAnimationFrame);
938static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_getComputedStyle);
939static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_matchMedia);
940static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_moveTo);
941static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_moveBy);
942static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_resizeTo);
943static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_resizeBy);
944static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_scroll);
945static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_scrollTo);
946static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_scrollBy);
947static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_requestIdleCallback);
948static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_cancelIdleCallback);
949static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_getSelection);
950static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_atob);
951static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_btoa);
952static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_setTimeout);
953static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_clearTimeout);
954static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_setInterval);
955static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_clearInterval);
956static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_queueMicrotask);
957static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_createImageBitmap);
958static JSC_DECLARE_HOST_FUNCTION(jsDOMWindowInstanceFunction_fetch);
959
960// Attributes
961
962static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindowConstructor);
963static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_window);
964static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_self);
965static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_self);
966static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_document);
967static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_name);
968static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_name);
969static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_location);
970static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_location);
971static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_history);
972static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_customElements);
973static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_locationbar);
974static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_locationbar);
975static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_menubar);
976static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_menubar);
977static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_personalbar);
978static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_personalbar);
979static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_scrollbars);
980static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_scrollbars);
981static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_statusbar);
982static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_statusbar);
983static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_toolbar);
984static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_toolbar);
985static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_status);
986static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_status);
987static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_closed);
988static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_frames);
989static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_frames);
990static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_length);
991static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_length);
992static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_top);
993static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_opener);
994static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_opener);
995static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_parent);
996static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_parent);
997static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_frameElement);
998static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_navigator);
999static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_applicationCache);
1000static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_event);
1001static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_event);
1002static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_defaultStatus);
1003static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_defaultStatus);
1004static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_defaultstatus);
1005static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_defaultstatus);
1006static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_offscreenBuffering);
1007static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_offscreenBuffering);
1008static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_clientInformation);
1009static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_clientInformation);
1010#if ENABLE(IOS_GESTURE_EVENTS)
1011static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ongesturechange);
1012static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_ongesturechange);
1013#endif
1014#if ENABLE(IOS_GESTURE_EVENTS)
1015static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ongestureend);
1016static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_ongestureend);
1017#endif
1018#if ENABLE(IOS_GESTURE_EVENTS)
1019static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ongesturestart);
1020static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_ongesturestart);
1021#endif
1022#if ENABLE(SPEECH_SYNTHESIS)
1023static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_speechSynthesis);
1024#endif
1025static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_openDatabase);
1026static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_openDatabase);
1027static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onabort);
1028static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onabort);
1029static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onblur);
1030static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onblur);
1031static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_oncanplay);
1032static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_oncanplay);
1033static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_oncanplaythrough);
1034static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_oncanplaythrough);
1035static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onchange);
1036static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onchange);
1037static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onclick);
1038static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onclick);
1039static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onclose);
1040static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onclose);
1041static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_oncontextmenu);
1042static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_oncontextmenu);
1043static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_oncuechange);
1044static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_oncuechange);
1045static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ondblclick);
1046static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_ondblclick);
1047static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ondrag);
1048static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_ondrag);
1049static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ondragend);
1050static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_ondragend);
1051static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ondragenter);
1052static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_ondragenter);
1053static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ondragleave);
1054static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_ondragleave);
1055static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ondragover);
1056static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_ondragover);
1057static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ondragstart);
1058static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_ondragstart);
1059static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ondrop);
1060static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_ondrop);
1061static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ondurationchange);
1062static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_ondurationchange);
1063static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onemptied);
1064static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onemptied);
1065static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onended);
1066static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onended);
1067static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onerror);
1068static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onerror);
1069static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onfocus);
1070static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onfocus);
1071static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_oninput);
1072static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_oninput);
1073static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_oninvalid);
1074static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_oninvalid);
1075static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onkeydown);
1076static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onkeydown);
1077static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onkeypress);
1078static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onkeypress);
1079static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onkeyup);
1080static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onkeyup);
1081static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onload);
1082static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onload);
1083static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onloadeddata);
1084static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onloadeddata);
1085static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onloadedmetadata);
1086static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onloadedmetadata);
1087static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onloadstart);
1088static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onloadstart);
1089static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onmousedown);
1090static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onmousedown);
1091static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onmouseenter);
1092static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onmouseenter);
1093static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onmouseleave);
1094static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onmouseleave);
1095static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onmousemove);
1096static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onmousemove);
1097static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onmouseout);
1098static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onmouseout);
1099static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onmouseover);
1100static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onmouseover);
1101static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onmouseup);
1102static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onmouseup);
1103static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onpause);
1104static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onpause);
1105static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onplay);
1106static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onplay);
1107static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onplaying);
1108static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onplaying);
1109static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onprogress);
1110static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onprogress);
1111static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onratechange);
1112static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onratechange);
1113static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onreset);
1114static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onreset);
1115static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onresize);
1116static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onresize);
1117static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onscroll);
1118static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onscroll);
1119static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onseeked);
1120static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onseeked);
1121static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onseeking);
1122static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onseeking);
1123static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onselect);
1124static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onselect);
1125static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onslotchange);
1126static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onslotchange);
1127static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onstalled);
1128static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onstalled);
1129static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onsubmit);
1130static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onsubmit);
1131static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onsuspend);
1132static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onsuspend);
1133static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ontimeupdate);
1134static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_ontimeupdate);
1135static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ontoggle);
1136static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_ontoggle);
1137static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onvolumechange);
1138static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onvolumechange);
1139static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onwaiting);
1140static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onwaiting);
1141static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onwebkitanimationend);
1142static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onwebkitanimationend);
1143static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onwebkitanimationiteration);
1144static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onwebkitanimationiteration);
1145static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onwebkitanimationstart);
1146static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onwebkitanimationstart);
1147static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onwebkittransitionend);
1148static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onwebkittransitionend);
1149static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onwheel);
1150static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onwheel);
1151static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onmousewheel);
1152static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onmousewheel);
1153static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onsearch);
1154static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onsearch);
1155#if ENABLE(TOUCH_EVENTS)
1156static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ontouchcancel);
1157static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_ontouchcancel);
1158#endif
1159#if ENABLE(TOUCH_EVENTS)
1160static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ontouchend);
1161static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_ontouchend);
1162#endif
1163#if ENABLE(TOUCH_EVENTS)
1164static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ontouchmove);
1165static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_ontouchmove);
1166#endif
1167#if ENABLE(TOUCH_EVENTS)
1168static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ontouchstart);
1169static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_ontouchstart);
1170#endif
1171#if ENABLE(TOUCH_EVENTS)
1172static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ontouchforcechange);
1173static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_ontouchforcechange);
1174#endif
1175#if ENABLE(MOUSE_FORCE_EVENTS)
1176static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onwebkitmouseforcechanged);
1177static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onwebkitmouseforcechanged);
1178#endif
1179#if ENABLE(MOUSE_FORCE_EVENTS)
1180static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onwebkitmouseforcedown);
1181static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onwebkitmouseforcedown);
1182#endif
1183#if ENABLE(MOUSE_FORCE_EVENTS)
1184static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onwebkitmouseforcewillbegin);
1185static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onwebkitmouseforcewillbegin);
1186#endif
1187#if ENABLE(MOUSE_FORCE_EVENTS)
1188static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onwebkitmouseforceup);
1189static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onwebkitmouseforceup);
1190#endif
1191static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onanimationstart);
1192static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onanimationstart);
1193static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onanimationiteration);
1194static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onanimationiteration);
1195static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onanimationend);
1196static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onanimationend);
1197static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onanimationcancel);
1198static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onanimationcancel);
1199static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ontransitionrun);
1200static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_ontransitionrun);
1201static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ontransitionstart);
1202static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_ontransitionstart);
1203static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ontransitionend);
1204static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_ontransitionend);
1205static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ontransitioncancel);
1206static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_ontransitioncancel);
1207static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ongotpointercapture);
1208static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_ongotpointercapture);
1209static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onlostpointercapture);
1210static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onlostpointercapture);
1211static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onpointerdown);
1212static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onpointerdown);
1213static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onpointermove);
1214static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onpointermove);
1215static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onpointerup);
1216static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onpointerup);
1217static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onpointercancel);
1218static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onpointercancel);
1219static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onpointerover);
1220static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onpointerover);
1221static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onpointerout);
1222static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onpointerout);
1223static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onpointerenter);
1224static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onpointerenter);
1225static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onpointerleave);
1226static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onpointerleave);
1227static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onselectstart);
1228static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onselectstart);
1229static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onselectionchange);
1230static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onselectionchange);
1231static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_screen);
1232static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_screen);
1233static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_innerWidth);
1234static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_innerWidth);
1235static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_innerHeight);
1236static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_innerHeight);
1237static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_scrollX);
1238static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_scrollX);
1239static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_pageXOffset);
1240static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_pageXOffset);
1241static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_scrollY);
1242static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_scrollY);
1243static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_pageYOffset);
1244static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_pageYOffset);
1245static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_screenX);
1246static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_screenX);
1247static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_screenLeft);
1248static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_screenLeft);
1249static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_screenY);
1250static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_screenY);
1251static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_screenTop);
1252static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_screenTop);
1253static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_outerWidth);
1254static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_outerWidth);
1255static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_outerHeight);
1256static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_outerHeight);
1257static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_devicePixelRatio);
1258static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_devicePixelRatio);
1259static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_styleMedia);
1260#if ENABLE(ORIENTATION_EVENTS)
1261static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_orientation);
1262#endif
1263#if ENABLE(ORIENTATION_EVENTS)
1264static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onorientationchange);
1265static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onorientationchange);
1266#endif
1267#if ENABLE(DEVICE_ORIENTATION)
1268static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ondevicemotion);
1269static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_ondevicemotion);
1270#endif
1271#if ENABLE(DEVICE_ORIENTATION)
1272static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ondeviceorientation);
1273static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_ondeviceorientation);
1274#endif
1275static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_visualViewport);
1276static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_visualViewport);
1277static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onafterprint);
1278static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onafterprint);
1279static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onbeforeprint);
1280static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onbeforeprint);
1281static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onbeforeunload);
1282static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onbeforeunload);
1283static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onhashchange);
1284static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onhashchange);
1285static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onlanguagechange);
1286static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onlanguagechange);
1287static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onmessage);
1288static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onmessage);
1289static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onoffline);
1290static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onoffline);
1291static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ononline);
1292static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_ononline);
1293static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onpagehide);
1294static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onpagehide);
1295static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onpageshow);
1296static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onpageshow);
1297static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onpopstate);
1298static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onpopstate);
1299static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onrejectionhandled);
1300static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onrejectionhandled);
1301static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onstorage);
1302static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onstorage);
1303static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onunhandledrejection);
1304static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onunhandledrejection);
1305static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_onunload);
1306static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_onunload);
1307static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_localStorage);
1308static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_origin);
1309static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_origin);
1310static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_isSecureContext);
1311static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_caches);
1312static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_indexedDB);
1313static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_webkitIndexedDB);
1314static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_crypto);
1315static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_performance);
1316static JSC_DECLARE_CUSTOM_SETTER(setJSDOMWindow_performance);
1317static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_sessionStorage);
1318#if ENABLE(TOUCH_EVENTS)
1319static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_TouchConstructor);
1320#endif
1321#if ENABLE(TOUCH_EVENTS)
1322static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_TouchEventConstructor);
1323#endif
1324#if ENABLE(TOUCH_EVENTS)
1325static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_TouchListConstructor);
1326#endif
1327#if ENABLE(WIRELESS_PLAYBACK_TARGET)
1328static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WebKitPlaybackTargetAvailabilityEventConstructor);
1329#endif
1330#if ENABLE(APPLE_PAY)
1331static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ApplePayErrorConstructor);
1332#endif
1333#if ENABLE(APPLE_PAY)
1334static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ApplePaySessionConstructor);
1335#endif
1336#if ENABLE(APPLE_PAY)
1337static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ApplePaySetupConstructor);
1338#endif
1339#if ENABLE(APPLE_PAY)
1340static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ApplePaySetupFeatureConstructor);
1341#endif
1342static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ClipboardConstructor);
1343static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ClipboardItemConstructor);
1344static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CacheConstructor);
1345static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CacheStorageConstructor);
1346static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ContactsManagerConstructor);
1347#if ENABLE(WEB_AUTHN)
1348static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CredentialConstructor);
1349#endif
1350#if ENABLE(WEB_AUTHN)
1351static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CredentialsContainerConstructor);
1352#endif
1353#if ENABLE(ENCRYPTED_MEDIA)
1354static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MediaKeyMessageEventConstructor);
1355#endif
1356#if ENABLE(ENCRYPTED_MEDIA)
1357static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MediaKeySessionConstructor);
1358#endif
1359#if ENABLE(ENCRYPTED_MEDIA)
1360static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MediaKeyStatusMapConstructor);
1361#endif
1362#if ENABLE(ENCRYPTED_MEDIA)
1363static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MediaKeySystemAccessConstructor);
1364#endif
1365#if ENABLE(ENCRYPTED_MEDIA)
1366static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MediaKeysConstructor);
1367#endif
1368#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
1369static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WebKitMediaKeyMessageEventConstructor);
1370#endif
1371#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
1372static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WebKitMediaKeyNeededEventConstructor);
1373#endif
1374#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
1375static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WebKitMediaKeySessionConstructor);
1376#endif
1377#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
1378static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WebKitMediaKeysConstructor);
1379#endif
1380static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_FileSystemConstructor);
1381static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_FileSystemDirectoryEntryConstructor);
1382static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_FileSystemDirectoryReaderConstructor);
1383static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_FileSystemEntryConstructor);
1384static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_FileSystemFileEntryConstructor);
1385static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HeadersConstructor);
1386static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_RequestConstructor);
1387static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ResponseConstructor);
1388#if ENABLE(GAMEPAD)
1389static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GamepadConstructor);
1390#endif
1391#if ENABLE(GAMEPAD)
1392static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GamepadButtonConstructor);
1393#endif
1394#if ENABLE(GAMEPAD)
1395static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GamepadEventConstructor);
1396#endif
1397#if ENABLE(GEOLOCATION)
1398static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GeolocationConstructor);
1399#endif
1400#if ENABLE(GEOLOCATION)
1401static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GeolocationCoordinatesConstructor);
1402#endif
1403#if ENABLE(GEOLOCATION)
1404static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GeolocationPositionConstructor);
1405#endif
1406#if ENABLE(GEOLOCATION)
1407static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GeolocationPositionErrorConstructor);
1408#endif
1409static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HighlightConstructor);
1410static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HighlightRegisterConstructor);
1411static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_IDBCursorConstructor);
1412static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_IDBCursorWithValueConstructor);
1413static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_IDBDatabaseConstructor);
1414static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_IDBFactoryConstructor);
1415static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_IDBIndexConstructor);
1416static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_IDBKeyRangeConstructor);
1417static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_IDBObjectStoreConstructor);
1418static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_IDBOpenDBRequestConstructor);
1419static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_IDBRequestConstructor);
1420static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_IDBTransactionConstructor);
1421static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_IDBVersionChangeEventConstructor);
1422static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MediaCapabilitiesConstructor);
1423#if ENABLE(MEDIA_STREAM)
1424static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_BlobEventConstructor);
1425#endif
1426#if ENABLE(MEDIA_STREAM)
1427static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MediaRecorderConstructor);
1428#endif
1429#if ENABLE(MEDIA_STREAM)
1430static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MediaRecorderErrorEventConstructor);
1431#endif
1432#if ENABLE(MEDIA_SESSION)
1433static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MediaMetadataConstructor);
1434#endif
1435#if ENABLE(MEDIA_SESSION)
1436static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MediaSessionConstructor);
1437#endif
1438#if ENABLE(MEDIA_SESSION_COORDINATOR)
1439static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MediaSessionCoordinatorConstructor);
1440#endif
1441#if ENABLE(MEDIA_SOURCE)
1442static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MediaSourceConstructor);
1443#endif
1444#if ENABLE(MEDIA_SOURCE)
1445static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SourceBufferConstructor);
1446#endif
1447#if ENABLE(MEDIA_SOURCE)
1448static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SourceBufferListConstructor);
1449#endif
1450#if ENABLE(MEDIA_STREAM)
1451static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CanvasCaptureMediaStreamTrackConstructor);
1452#endif
1453#if ENABLE(MEDIA_STREAM)
1454static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MediaDeviceInfoConstructor);
1455#endif
1456#if ENABLE(MEDIA_STREAM)
1457static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MediaDevicesConstructor);
1458#endif
1459#if ENABLE(MEDIA_STREAM)
1460static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MediaStreamConstructor);
1461#endif
1462#if ENABLE(MEDIA_STREAM)
1463static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MediaStreamTrackConstructor);
1464#endif
1465#if ENABLE(MEDIA_STREAM)
1466static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MediaStreamTrackEventConstructor);
1467#endif
1468#if ENABLE(MEDIA_STREAM)
1469static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_OverconstrainedErrorConstructor);
1470#endif
1471#if ENABLE(MEDIA_STREAM)
1472static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_OverconstrainedErrorEventConstructor);
1473#endif
1474#if ENABLE(WEB_RTC)
1475static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_RTCCertificateConstructor);
1476#endif
1477#if ENABLE(WEB_RTC)
1478static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_RTCDTMFSenderConstructor);
1479#endif
1480#if ENABLE(WEB_RTC)
1481static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_RTCDTMFToneChangeEventConstructor);
1482#endif
1483#if ENABLE(WEB_RTC)
1484static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_RTCDataChannelConstructor);
1485#endif
1486#if ENABLE(WEB_RTC)
1487static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_RTCDataChannelEventConstructor);
1488#endif
1489#if ENABLE(WEB_RTC)
1490static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_RTCIceCandidateConstructor);
1491#endif
1492#if ENABLE(WEB_RTC)
1493static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_RTCIceTransportConstructor);
1494#endif
1495#if ENABLE(WEB_RTC)
1496static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_RTCPeerConnectionConstructor);
1497#endif
1498#if ENABLE(WEB_RTC)
1499static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_RTCPeerConnectionIceErrorEventConstructor);
1500#endif
1501#if ENABLE(WEB_RTC)
1502static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_RTCPeerConnectionIceEventConstructor);
1503#endif
1504#if ENABLE(WEB_RTC)
1505static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_RTCRtpReceiverConstructor);
1506#endif
1507#if ENABLE(WEB_RTC)
1508static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SFrameTransformConstructor);
1509#endif
1510#if ENABLE(WEB_RTC)
1511static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_RTCRtpScriptTransformConstructor);
1512#endif
1513#if ENABLE(WEB_RTC)
1514static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_RTCRtpSenderConstructor);
1515#endif
1516#if ENABLE(WEB_RTC)
1517static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_RTCRtpTransceiverConstructor);
1518#endif
1519#if ENABLE(WEB_RTC)
1520static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_RTCSessionDescriptionConstructor);
1521#endif
1522#if ENABLE(WEB_RTC)
1523static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_RTCStatsReportConstructor);
1524#endif
1525#if ENABLE(WEB_RTC)
1526static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_RTCTrackEventConstructor);
1527#endif
1528#if ENABLE(MODEL_ELEMENT)
1529static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLModelElementConstructor);
1530#endif
1531#if ENABLE(NOTIFICATIONS)
1532static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_NotificationConstructor);
1533#endif
1534#if ENABLE(PAYMENT_REQUEST)
1535static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MerchantValidationEventConstructor);
1536#endif
1537#if ENABLE(PAYMENT_REQUEST)
1538static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_PaymentAddressConstructor);
1539#endif
1540#if ENABLE(PAYMENT_REQUEST)
1541static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_PaymentMethodChangeEventConstructor);
1542#endif
1543#if ENABLE(PAYMENT_REQUEST)
1544static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_PaymentRequestConstructor);
1545#endif
1546#if ENABLE(PAYMENT_REQUEST)
1547static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_PaymentRequestUpdateEventConstructor);
1548#endif
1549#if ENABLE(PAYMENT_REQUEST)
1550static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_PaymentResponseConstructor);
1551#endif
1552#if ENABLE(PICTURE_IN_PICTURE_API)
1553static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_EnterPictureInPictureEventConstructor);
1554#endif
1555#if ENABLE(PICTURE_IN_PICTURE_API)
1556static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_PictureInPictureWindowConstructor);
1557#endif
1558#if ENABLE(WIRELESS_PLAYBACK_TARGET)
1559static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_RemotePlaybackConstructor);
1560#endif
1561static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_webkitSpeechRecognitionConstructor);
1562static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SpeechRecognitionAlternativeConstructor);
1563static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SpeechRecognitionErrorEventConstructor);
1564static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SpeechRecognitionEventConstructor);
1565static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SpeechRecognitionResultConstructor);
1566static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SpeechRecognitionResultListConstructor);
1567#if ENABLE(SPEECH_SYNTHESIS)
1568static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SpeechSynthesisEventConstructor);
1569#endif
1570#if ENABLE(SPEECH_SYNTHESIS)
1571static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SpeechSynthesisUtteranceConstructor);
1572#endif
1573static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ByteLengthQueuingStrategyConstructor);
1574static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CountQueuingStrategyConstructor);
1575static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ReadableByteStreamControllerConstructor);
1576static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ReadableStreamConstructor);
1577static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ReadableStreamBYOBReaderConstructor);
1578static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ReadableStreamBYOBRequestConstructor);
1579static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ReadableStreamDefaultControllerConstructor);
1580static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ReadableStreamDefaultReaderConstructor);
1581static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_TransformStreamConstructor);
1582static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_TransformStreamDefaultControllerConstructor);
1583static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WritableStreamConstructor);
1584static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WritableStreamDefaultControllerConstructor);
1585static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WritableStreamDefaultWriterConstructor);
1586#if ENABLE(WEB_AUDIO)
1587static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_AnalyserNodeConstructor);
1588#endif
1589#if ENABLE(WEB_AUDIO)
1590static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_AudioBufferConstructor);
1591#endif
1592#if ENABLE(WEB_AUDIO)
1593static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_AudioBufferSourceNodeConstructor);
1594#endif
1595#if ENABLE(WEB_AUDIO)
1596static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_AudioContextConstructor);
1597#endif
1598#if ENABLE(WEB_AUDIO)
1599static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_AudioDestinationNodeConstructor);
1600#endif
1601#if ENABLE(WEB_AUDIO)
1602static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_AudioListenerConstructor);
1603#endif
1604#if ENABLE(WEB_AUDIO)
1605static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_AudioNodeConstructor);
1606#endif
1607#if ENABLE(WEB_AUDIO)
1608static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_AudioParamConstructor);
1609#endif
1610#if ENABLE(WEB_AUDIO)
1611static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_AudioParamMapConstructor);
1612#endif
1613#if ENABLE(WEB_AUDIO)
1614static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_AudioProcessingEventConstructor);
1615#endif
1616#if ENABLE(WEB_AUDIO)
1617static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_AudioScheduledSourceNodeConstructor);
1618#endif
1619#if ENABLE(WEB_AUDIO)
1620static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_AudioWorkletConstructor);
1621#endif
1622#if ENABLE(WEB_AUDIO)
1623static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_AudioWorkletNodeConstructor);
1624#endif
1625#if ENABLE(WEB_AUDIO)
1626static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_BaseAudioContextConstructor);
1627#endif
1628#if ENABLE(WEB_AUDIO)
1629static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_BiquadFilterNodeConstructor);
1630#endif
1631#if ENABLE(WEB_AUDIO)
1632static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ChannelMergerNodeConstructor);
1633#endif
1634#if ENABLE(WEB_AUDIO)
1635static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ChannelSplitterNodeConstructor);
1636#endif
1637#if ENABLE(WEB_AUDIO)
1638static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ConstantSourceNodeConstructor);
1639#endif
1640#if ENABLE(WEB_AUDIO)
1641static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ConvolverNodeConstructor);
1642#endif
1643#if ENABLE(WEB_AUDIO)
1644static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_DelayNodeConstructor);
1645#endif
1646#if ENABLE(WEB_AUDIO)
1647static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_DynamicsCompressorNodeConstructor);
1648#endif
1649#if ENABLE(WEB_AUDIO)
1650static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GainNodeConstructor);
1651#endif
1652#if ENABLE(WEB_AUDIO)
1653static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_IIRFilterNodeConstructor);
1654#endif
1655#if ENABLE(VIDEO) && ENABLE(WEB_AUDIO)
1656static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MediaElementAudioSourceNodeConstructor);
1657#endif
1658#if ENABLE(MEDIA_STREAM) && ENABLE(WEB_AUDIO)
1659static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MediaStreamAudioDestinationNodeConstructor);
1660#endif
1661#if ENABLE(MEDIA_STREAM) && ENABLE(WEB_AUDIO)
1662static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MediaStreamAudioSourceNodeConstructor);
1663#endif
1664#if ENABLE(WEB_AUDIO)
1665static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_OfflineAudioCompletionEventConstructor);
1666#endif
1667#if ENABLE(WEB_AUDIO)
1668static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_OfflineAudioContextConstructor);
1669#endif
1670#if ENABLE(WEB_AUDIO)
1671static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_OscillatorNodeConstructor);
1672#endif
1673#if ENABLE(WEB_AUDIO)
1674static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_PannerNodeConstructor);
1675#endif
1676#if ENABLE(WEB_AUDIO)
1677static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_PeriodicWaveConstructor);
1678#endif
1679#if ENABLE(WEB_AUDIO)
1680static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ScriptProcessorNodeConstructor);
1681#endif
1682#if ENABLE(WEB_AUDIO)
1683static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_StereoPannerNodeConstructor);
1684#endif
1685#if ENABLE(WEB_AUDIO)
1686static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WaveShaperNodeConstructor);
1687#endif
1688#if ENABLE(WEB_AUTHN)
1689static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_AuthenticatorAssertionResponseConstructor);
1690#endif
1691#if ENABLE(WEB_AUTHN)
1692static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_AuthenticatorAttestationResponseConstructor);
1693#endif
1694#if ENABLE(WEB_AUTHN)
1695static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_AuthenticatorResponseConstructor);
1696#endif
1697#if ENABLE(WEB_AUTHN)
1698static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_PublicKeyCredentialConstructor);
1699#endif
1700static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_DatabaseConstructor);
1701static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SQLErrorConstructor);
1702static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SQLResultSetConstructor);
1703static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SQLResultSetRowListConstructor);
1704static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SQLTransactionConstructor);
1705#if ENABLE(WEBGPU)
1706static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GPUBufferUsageConstructor);
1707#endif
1708#if ENABLE(WEBGPU)
1709static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GPUCanvasContextConstructor);
1710#endif
1711#if ENABLE(WEBGPU)
1712static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GPUColorWriteConstructor);
1713#endif
1714#if ENABLE(WEBGPU)
1715static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GPUOutOfMemoryErrorConstructor);
1716#endif
1717#if ENABLE(WEBGPU)
1718static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GPUShaderStageConstructor);
1719#endif
1720#if ENABLE(WEBGPU)
1721static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GPUTextureUsageConstructor);
1722#endif
1723#if ENABLE(WEBGPU)
1724static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GPUUncapturedErrorEventConstructor);
1725#endif
1726#if ENABLE(WEBGPU)
1727static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GPUValidationErrorConstructor);
1728#endif
1729#if ENABLE(WEBGPU)
1730static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GPUConstructor);
1731#endif
1732#if ENABLE(WEBGPU)
1733static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GPUAdapterConstructor);
1734#endif
1735#if ENABLE(WEBGPU)
1736static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GPUBindGroupConstructor);
1737#endif
1738#if ENABLE(WEBGPU)
1739static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GPUBindGroupLayoutConstructor);
1740#endif
1741#if ENABLE(WEBGPU)
1742static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GPUBufferConstructor);
1743#endif
1744#if ENABLE(WEBGPU)
1745static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GPUCommandBufferConstructor);
1746#endif
1747#if ENABLE(WEBGPU)
1748static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GPUCommandEncoderConstructor);
1749#endif
1750#if ENABLE(WEBGPU)
1751static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GPUComputePassEncoderConstructor);
1752#endif
1753#if ENABLE(WEBGPU)
1754static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GPUComputePipelineConstructor);
1755#endif
1756#if ENABLE(WEBGPU)
1757static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GPUDeviceConstructor);
1758#endif
1759#if ENABLE(WEBGPU)
1760static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GPUPipelineLayoutConstructor);
1761#endif
1762#if ENABLE(WEBGPU)
1763static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GPUProgrammablePassEncoderConstructor);
1764#endif
1765#if ENABLE(WEBGPU)
1766static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GPUQueueConstructor);
1767#endif
1768#if ENABLE(WEBGPU)
1769static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GPURenderPassEncoderConstructor);
1770#endif
1771#if ENABLE(WEBGPU)
1772static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GPURenderPipelineConstructor);
1773#endif
1774#if ENABLE(WEBGPU)
1775static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GPUSamplerConstructor);
1776#endif
1777#if ENABLE(WEBGPU)
1778static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GPUShaderModuleConstructor);
1779#endif
1780#if ENABLE(WEBGPU)
1781static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GPUSwapChainConstructor);
1782#endif
1783#if ENABLE(WEBGPU)
1784static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GPUTextureConstructor);
1785#endif
1786#if ENABLE(WEBGPU)
1787static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_GPUTextureViewConstructor);
1788#endif
1789static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CloseEventConstructor);
1790static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WebSocketConstructor);
1791#if ENABLE(WEBXR)
1792static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_XRBoundedReferenceSpaceConstructor);
1793#endif
1794#if ENABLE(WEBXR)
1795static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_XRFrameConstructor);
1796#endif
1797#if ENABLE(WEBXR)
1798static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_XRInputSourceConstructor);
1799#endif
1800#if ENABLE(WEBXR)
1801static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_XRInputSourceArrayConstructor);
1802#endif
1803#if ENABLE(WEBXR)
1804static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_XRLayerConstructor);
1805#endif
1806#if ENABLE(WEBXR)
1807static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_XRPoseConstructor);
1808#endif
1809#if ENABLE(WEBXR)
1810static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_XRReferenceSpaceConstructor);
1811#endif
1812#if ENABLE(WEBXR)
1813static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_XRRenderStateConstructor);
1814#endif
1815#if ENABLE(WEBXR)
1816static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_XRRigidTransformConstructor);
1817#endif
1818#if ENABLE(WEBXR)
1819static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_XRSessionConstructor);
1820#endif
1821#if ENABLE(WEBXR)
1822static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_XRSpaceConstructor);
1823#endif
1824#if ENABLE(WEBXR)
1825static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_XRSystemConstructor);
1826#endif
1827#if ENABLE(WEBXR)
1828static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_XRViewConstructor);
1829#endif
1830#if ENABLE(WEBXR)
1831static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_XRViewerPoseConstructor);
1832#endif
1833#if ENABLE(WEBXR)
1834static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_XRViewportConstructor);
1835#endif
1836#if ENABLE(WEBXR)
1837static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_XRWebGLLayerConstructor);
1838#endif
1839#if ENABLE(WEBXR)
1840static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_XRInputSourceEventConstructor);
1841#endif
1842#if ENABLE(WEBXR)
1843static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_XRInputSourcesChangeEventConstructor);
1844#endif
1845#if ENABLE(WEBXR)
1846static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_XRReferenceSpaceEventConstructor);
1847#endif
1848#if ENABLE(WEBXR)
1849static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_XRSessionEventConstructor);
1850#endif
1851static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_AnimationEffectConstructor);
1852static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_AnimationPlaybackEventConstructor);
1853static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_AnimationTimelineConstructor);
1854static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CSSAnimationConstructor);
1855static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CSSTransitionConstructor);
1856static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_DocumentTimelineConstructor);
1857static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_KeyframeEffectConstructor);
1858static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_AnimationConstructor);
1859#if ENABLE(WEB_CRYPTO)
1860static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CryptoKeyConstructor);
1861#endif
1862#if ENABLE(WEB_CRYPTO)
1863static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SubtleCryptoConstructor);
1864#endif
1865static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CSSConditionRuleConstructor);
1866static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CSSCounterStyleRuleConstructor);
1867static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CSSFontFaceRuleConstructor);
1868static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CSSGroupingRuleConstructor);
1869static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CSSImportRuleConstructor);
1870static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CSSKeyframeRuleConstructor);
1871static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CSSKeyframesRuleConstructor);
1872static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CSSMediaRuleConstructor);
1873static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CSSNamespaceRuleConstructor);
1874static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CSSPageRuleConstructor);
1875static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CSSRuleConstructor);
1876static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CSSRuleListConstructor);
1877static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CSSStyleDeclarationConstructor);
1878static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CSSStyleRuleConstructor);
1879static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CSSStyleSheetConstructor);
1880static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CSSSupportsRuleConstructor);
1881static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CSSConstructor);
1882static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_DOMMatrixConstructor);
1883static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WebKitCSSMatrixConstructor);
1884static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_DOMMatrixReadOnlyConstructor);
1885static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CounterConstructor);
1886static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CSSPrimitiveValueConstructor);
1887static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_RGBColorConstructor);
1888static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_RectConstructor);
1889static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CSSValueConstructor);
1890static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CSSValueListConstructor);
1891static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_FontFaceConstructor);
1892static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_FontFaceSetConstructor);
1893static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MediaListConstructor);
1894static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MediaQueryListConstructor);
1895static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MediaQueryListEventConstructor);
1896static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_StyleSheetConstructor);
1897static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_StyleSheetListConstructor);
1898#if ENABLE(CSS_TYPED_OM)
1899static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_StylePropertyMapConstructor);
1900#endif
1901#if ENABLE(CSS_TYPED_OM)
1902static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_StylePropertyMapReadOnlyConstructor);
1903#endif
1904#if ENABLE(CSS_TYPED_OM)
1905static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CSSImageValueConstructor);
1906#endif
1907#if ENABLE(CSS_TYPED_OM)
1908static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CSSNumericValueConstructor);
1909#endif
1910#if ENABLE(CSS_TYPED_OM)
1911static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CSSStyleValueConstructor);
1912#endif
1913#if ENABLE(CSS_TYPED_OM)
1914static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CSSUnitValueConstructor);
1915#endif
1916#if ENABLE(CSS_TYPED_OM)
1917static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CSSUnparsedValueConstructor);
1918#endif
1919static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_AbortControllerConstructor);
1920static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_AbortSignalConstructor);
1921static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_AbstractRangeConstructor);
1922static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_AnimationEventConstructor);
1923static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_AttrConstructor);
1924static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_BeforeLoadEventConstructor);
1925static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_BeforeUnloadEventConstructor);
1926static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CDATASectionConstructor);
1927static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CharacterDataConstructor);
1928static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ClipboardEventConstructor);
1929static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CommentConstructor);
1930static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CompositionEventConstructor);
1931static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CustomElementRegistryConstructor);
1932static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CustomEventConstructor);
1933static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_DOMExceptionConstructor);
1934static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_DOMImplementationConstructor);
1935static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_DOMPointConstructor);
1936static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_DOMPointReadOnlyConstructor);
1937static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_DOMQuadConstructor);
1938static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_DOMRectConstructor);
1939static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_DOMRectListConstructor);
1940static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_DOMRectReadOnlyConstructor);
1941static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_DOMStringListConstructor);
1942static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_DOMStringMapConstructor);
1943static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_DataTransferConstructor);
1944static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_DataTransferItemConstructor);
1945static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_DataTransferItemListConstructor);
1946#if ENABLE(DEVICE_ORIENTATION)
1947static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_DeviceMotionEventConstructor);
1948#endif
1949#if ENABLE(DEVICE_ORIENTATION)
1950static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_DeviceOrientationEventConstructor);
1951#endif
1952static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_DocumentConstructor);
1953static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_DocumentFragmentConstructor);
1954static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_DocumentTypeConstructor);
1955static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_DragEventConstructor);
1956static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ElementConstructor);
1957static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ErrorEventConstructor);
1958static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_EventConstructor);
1959static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_EventTargetConstructor);
1960static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_FocusEventConstructor);
1961static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HashChangeEventConstructor);
1962static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_IdleDeadlineConstructor);
1963static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_InputEventConstructor);
1964static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_KeyboardEventConstructor);
1965#if ENABLE(CHANNEL_MESSAGING)
1966static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MessageChannelConstructor);
1967#endif
1968static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MessageEventConstructor);
1969static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MessagePortConstructor);
1970static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MouseEventConstructor);
1971static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MutationEventConstructor);
1972static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MutationObserverConstructor);
1973static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WebKitMutationObserverConstructor);
1974static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MutationRecordConstructor);
1975static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_NamedNodeMapConstructor);
1976static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_NodeConstructor);
1977static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_NodeFilterConstructor);
1978static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_NodeIteratorConstructor);
1979static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_NodeListConstructor);
1980static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_OverflowEventConstructor);
1981static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_PageTransitionEventConstructor);
1982static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_PointerEventConstructor);
1983static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_PopStateEventConstructor);
1984static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ProcessingInstructionConstructor);
1985static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ProgressEventConstructor);
1986static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_PromiseRejectionEventConstructor);
1987static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_RangeConstructor);
1988static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SecurityPolicyViolationEventConstructor);
1989static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ShadowRootConstructor);
1990static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_StaticRangeConstructor);
1991static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_TextConstructor);
1992static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_TextDecoderConstructor);
1993static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_TextDecoderStreamConstructor);
1994static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_TextDecoderStreamDecoderConstructor);
1995static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_TextEncoderConstructor);
1996static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_TextEncoderStreamConstructor);
1997static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_TextEncoderStreamEncoderConstructor);
1998static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_TextEventConstructor);
1999static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_TransitionEventConstructor);
2000static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_TreeWalkerConstructor);
2001static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_UIEventConstructor);
2002static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WebKitAnimationEventConstructor);
2003static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WebKitTransitionEventConstructor);
2004static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WheelEventConstructor);
2005static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_XMLDocumentConstructor);
2006static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGDocumentConstructor);
2007static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_BlobConstructor);
2008static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_FileConstructor);
2009static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_FileListConstructor);
2010static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_FileReaderConstructor);
2011static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_FormDataConstructor);
2012static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_DOMTokenListConstructor);
2013static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_URLConstructor);
2014static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_webkitURLConstructor);
2015static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLAllCollectionConstructor);
2016static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLAnchorElementConstructor);
2017static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLAreaElementConstructor);
2018#if ENABLE(ATTACHMENT_ELEMENT)
2019static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLAttachmentElementConstructor);
2020#endif
2021#if ENABLE(VIDEO)
2022static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLAudioElementConstructor);
2023#endif
2024#if ENABLE(VIDEO)
2025static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_AudioConstructor);
2026#endif
2027static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLBRElementConstructor);
2028static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLBaseElementConstructor);
2029static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLBodyElementConstructor);
2030static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLButtonElementConstructor);
2031static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLCanvasElementConstructor);
2032static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLCollectionConstructor);
2033static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLDListElementConstructor);
2034static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLDataElementConstructor);
2035#if ENABLE(DATALIST_ELEMENT)
2036static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLDataListElementConstructor);
2037#endif
2038static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLDetailsElementConstructor);
2039static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLDialogElementConstructor);
2040static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLDirectoryElementConstructor);
2041static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLDivElementConstructor);
2042static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLDocumentConstructor);
2043static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLElementConstructor);
2044static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLEmbedElementConstructor);
2045static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLFieldSetElementConstructor);
2046static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLFontElementConstructor);
2047static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLFormControlsCollectionConstructor);
2048static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLFormElementConstructor);
2049static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLFrameElementConstructor);
2050static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLFrameSetElementConstructor);
2051static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLHRElementConstructor);
2052static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLHeadElementConstructor);
2053static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLHeadingElementConstructor);
2054static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLHtmlElementConstructor);
2055static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLIFrameElementConstructor);
2056static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLImageElementConstructor);
2057static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ImageConstructor);
2058static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLInputElementConstructor);
2059static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLKeygenElementConstructor);
2060static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLLIElementConstructor);
2061static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLLabelElementConstructor);
2062static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLLegendElementConstructor);
2063static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLLinkElementConstructor);
2064static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLMapElementConstructor);
2065static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLMarqueeElementConstructor);
2066#if ENABLE(VIDEO)
2067static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLMediaElementConstructor);
2068#endif
2069static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLMenuElementConstructor);
2070static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLMenuItemElementConstructor);
2071static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLMetaElementConstructor);
2072static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLMeterElementConstructor);
2073static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLModElementConstructor);
2074static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLOListElementConstructor);
2075static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLObjectElementConstructor);
2076static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLOptGroupElementConstructor);
2077static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLOptionElementConstructor);
2078static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_OptionConstructor);
2079static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLOptionsCollectionConstructor);
2080static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLOutputElementConstructor);
2081static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLParagraphElementConstructor);
2082static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLParamElementConstructor);
2083static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLPictureElementConstructor);
2084static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLPreElementConstructor);
2085static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLProgressElementConstructor);
2086static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLQuoteElementConstructor);
2087static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLScriptElementConstructor);
2088static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLSelectElementConstructor);
2089static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLSlotElementConstructor);
2090static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLSourceElementConstructor);
2091static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLSpanElementConstructor);
2092static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLStyleElementConstructor);
2093static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLTableCaptionElementConstructor);
2094static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLTableCellElementConstructor);
2095static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLTableColElementConstructor);
2096static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLTableElementConstructor);
2097static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLTableRowElementConstructor);
2098static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLTableSectionElementConstructor);
2099static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLTemplateElementConstructor);
2100static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLTextAreaElementConstructor);
2101static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLTimeElementConstructor);
2102static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLTitleElementConstructor);
2103#if ENABLE(VIDEO)
2104static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLTrackElementConstructor);
2105#endif
2106static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLUListElementConstructor);
2107static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLUnknownElementConstructor);
2108#if ENABLE(VIDEO)
2109static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HTMLVideoElementConstructor);
2110#endif
2111static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ImageBitmapConstructor);
2112static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ImageDataConstructor);
2113#if ENABLE(VIDEO)
2114static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MediaControllerConstructor);
2115#endif
2116#if ENABLE(ENCRYPTED_MEDIA)
2117static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MediaEncryptedEventConstructor);
2118#endif
2119#if ENABLE(VIDEO)
2120static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MediaErrorConstructor);
2121#endif
2122#if ENABLE(OFFSCREEN_CANVAS)
2123static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_OffscreenCanvasConstructor);
2124#endif
2125static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_RadioNodeListConstructor);
2126static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_TextMetricsConstructor);
2127#if ENABLE(VIDEO)
2128static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_TimeRangesConstructor);
2129#endif
2130static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_URLSearchParamsConstructor);
2131static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ValidityStateConstructor);
2132#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
2133static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WebKitMediaKeyErrorConstructor);
2134#endif
2135static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CanvasGradientConstructor);
2136static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CanvasPatternConstructor);
2137static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CanvasRenderingContext2DConstructor);
2138static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ImageBitmapRenderingContextConstructor);
2139#if ENABLE(OFFSCREEN_CANVAS)
2140static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_OffscreenCanvasRenderingContext2DConstructor);
2141#endif
2142static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_Path2DConstructor);
2143#if ENABLE(WEBGL2)
2144static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WebGL2RenderingContextConstructor);
2145#endif
2146#if ENABLE(WEBGL)
2147static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WebGLActiveInfoConstructor);
2148#endif
2149#if ENABLE(WEBGL)
2150static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WebGLBufferConstructor);
2151#endif
2152#if ENABLE(WEBGL)
2153static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WebGLContextEventConstructor);
2154#endif
2155#if ENABLE(WEBGL)
2156static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WebGLFramebufferConstructor);
2157#endif
2158#if ENABLE(WEBGL)
2159static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WebGLProgramConstructor);
2160#endif
2161#if ENABLE(WEBGL)
2162static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WebGLQueryConstructor);
2163#endif
2164#if ENABLE(WEBGL)
2165static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WebGLRenderbufferConstructor);
2166#endif
2167#if ENABLE(WEBGL)
2168static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WebGLRenderingContextConstructor);
2169#endif
2170#if ENABLE(WEBGL)
2171static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WebGLSamplerConstructor);
2172#endif
2173#if ENABLE(WEBGL)
2174static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WebGLShaderConstructor);
2175#endif
2176#if ENABLE(WEBGL)
2177static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WebGLShaderPrecisionFormatConstructor);
2178#endif
2179#if ENABLE(WEBGL)
2180static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WebGLSyncConstructor);
2181#endif
2182#if ENABLE(WEBGL)
2183static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WebGLTextureConstructor);
2184#endif
2185#if ENABLE(WEBGL2)
2186static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WebGLTransformFeedbackConstructor);
2187#endif
2188#if ENABLE(WEBGL)
2189static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WebGLUniformLocationConstructor);
2190#endif
2191#if ENABLE(WEBGL2)
2192static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WebGLVertexArrayObjectConstructor);
2193#endif
2194#if ENABLE(VIDEO)
2195static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_AudioTrackConstructor);
2196#endif
2197#if ENABLE(VIDEO)
2198static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_AudioTrackListConstructor);
2199#endif
2200#if ENABLE(VIDEO)
2201static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_DataCueConstructor);
2202#endif
2203#if ENABLE(VIDEO)
2204static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_TextTrackConstructor);
2205#endif
2206#if ENABLE(VIDEO)
2207static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_TextTrackCueConstructor);
2208#endif
2209#if ENABLE(VIDEO)
2210static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_TextTrackCueListConstructor);
2211#endif
2212#if ENABLE(VIDEO)
2213static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_TextTrackListConstructor);
2214#endif
2215#if ENABLE(VIDEO)
2216static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_TrackEventConstructor);
2217#endif
2218#if ENABLE(VIDEO)
2219static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_VTTCueConstructor);
2220#endif
2221#if ENABLE(VIDEO)
2222static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_VTTRegionConstructor);
2223#endif
2224#if ENABLE(VIDEO)
2225static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_VideoTrackConstructor);
2226#endif
2227#if ENABLE(VIDEO)
2228static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_VideoTrackListConstructor);
2229#endif
2230static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ApplicationCacheConstructor);
2231#if ENABLE(MATHML)
2232static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MathMLElementConstructor);
2233#endif
2234#if ENABLE(MATHML)
2235static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MathMLMathElementConstructor);
2236#endif
2237static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_BarPropConstructor);
2238static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_CryptoConstructor);
2239static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SelectionConstructor);
2240static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WindowConstructor);
2241static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_EventSourceConstructor);
2242static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_HistoryConstructor);
2243#if ENABLE(INTERSECTION_OBSERVER)
2244static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_IntersectionObserverConstructor);
2245#endif
2246#if ENABLE(INTERSECTION_OBSERVER)
2247static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_IntersectionObserverEntryConstructor);
2248#endif
2249static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_LocationConstructor);
2250static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_NavigatorConstructor);
2251static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_PerformanceConstructor);
2252static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_PerformanceEntryConstructor);
2253static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_PerformanceMarkConstructor);
2254static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_PerformanceMeasureConstructor);
2255static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_PerformanceNavigationConstructor);
2256static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_PerformanceNavigationTimingConstructor);
2257static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_PerformanceObserverConstructor);
2258static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_PerformanceObserverEntryListConstructor);
2259static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_PerformancePaintTimingConstructor);
2260static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_PerformanceResourceTimingConstructor);
2261static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_PerformanceServerTimingConstructor);
2262static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_PerformanceTimingConstructor);
2263#if ENABLE(RESIZE_OBSERVER)
2264static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ResizeObserverConstructor);
2265#endif
2266#if ENABLE(RESIZE_OBSERVER)
2267static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ResizeObserverEntryConstructor);
2268#endif
2269static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ScreenConstructor);
2270static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_UndoItemConstructor);
2271static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_UndoManagerConstructor);
2272#if ENABLE(USER_MESSAGE_HANDLERS)
2273static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_UserMessageHandlerConstructor);
2274#endif
2275#if ENABLE(USER_MESSAGE_HANDLERS)
2276static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_UserMessageHandlersNamespaceConstructor);
2277#endif
2278static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_VisualViewportConstructor);
2279#if ENABLE(USER_MESSAGE_HANDLERS)
2280static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WebKitNamespaceConstructor);
2281#endif
2282static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WebKitPointConstructor);
2283static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MimeTypeConstructor);
2284static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_MimeTypeArrayConstructor);
2285static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_PluginConstructor);
2286static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_PluginArrayConstructor);
2287static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_StorageConstructor);
2288static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_StorageEventConstructor);
2289static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGAElementConstructor);
2290static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGAltGlyphDefElementConstructor);
2291static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGAltGlyphElementConstructor);
2292static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGAltGlyphItemElementConstructor);
2293static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGAngleConstructor);
2294static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGAnimateColorElementConstructor);
2295static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGAnimateElementConstructor);
2296static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGAnimateMotionElementConstructor);
2297static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGAnimateTransformElementConstructor);
2298static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGAnimatedAngleConstructor);
2299static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGAnimatedBooleanConstructor);
2300static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGAnimatedEnumerationConstructor);
2301static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGAnimatedIntegerConstructor);
2302static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGAnimatedLengthConstructor);
2303static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGAnimatedLengthListConstructor);
2304static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGAnimatedNumberConstructor);
2305static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGAnimatedNumberListConstructor);
2306static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGAnimatedPreserveAspectRatioConstructor);
2307static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGAnimatedRectConstructor);
2308static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGAnimatedStringConstructor);
2309static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGAnimatedTransformListConstructor);
2310static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGAnimationElementConstructor);
2311static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGCircleElementConstructor);
2312static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGClipPathElementConstructor);
2313static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGComponentTransferFunctionElementConstructor);
2314static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGCursorElementConstructor);
2315static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGDefsElementConstructor);
2316static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGDescElementConstructor);
2317static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGElementConstructor);
2318static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGEllipseElementConstructor);
2319static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGFEBlendElementConstructor);
2320static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGFEColorMatrixElementConstructor);
2321static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGFEComponentTransferElementConstructor);
2322static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGFECompositeElementConstructor);
2323static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGFEConvolveMatrixElementConstructor);
2324static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGFEDiffuseLightingElementConstructor);
2325static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGFEDisplacementMapElementConstructor);
2326static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGFEDistantLightElementConstructor);
2327static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGFEDropShadowElementConstructor);
2328static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGFEFloodElementConstructor);
2329static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGFEFuncAElementConstructor);
2330static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGFEFuncBElementConstructor);
2331static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGFEFuncGElementConstructor);
2332static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGFEFuncRElementConstructor);
2333static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGFEGaussianBlurElementConstructor);
2334static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGFEImageElementConstructor);
2335static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGFEMergeElementConstructor);
2336static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGFEMergeNodeElementConstructor);
2337static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGFEMorphologyElementConstructor);
2338static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGFEOffsetElementConstructor);
2339static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGFEPointLightElementConstructor);
2340static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGFESpecularLightingElementConstructor);
2341static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGFESpotLightElementConstructor);
2342static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGFETileElementConstructor);
2343static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGFETurbulenceElementConstructor);
2344static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGFilterElementConstructor);
2345static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGFontElementConstructor);
2346static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGFontFaceElementConstructor);
2347static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGFontFaceFormatElementConstructor);
2348static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGFontFaceNameElementConstructor);
2349static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGFontFaceSrcElementConstructor);
2350static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGFontFaceUriElementConstructor);
2351static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGForeignObjectElementConstructor);
2352static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGGElementConstructor);
2353static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGGeometryElementConstructor);
2354static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGGlyphElementConstructor);
2355static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGGlyphRefElementConstructor);
2356static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGGradientElementConstructor);
2357static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGGraphicsElementConstructor);
2358static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGHKernElementConstructor);
2359static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGImageElementConstructor);
2360static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGLengthConstructor);
2361static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGLengthListConstructor);
2362static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGLineElementConstructor);
2363static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGLinearGradientElementConstructor);
2364static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGMPathElementConstructor);
2365static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGMarkerElementConstructor);
2366static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGMaskElementConstructor);
2367static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGMatrixConstructor);
2368static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGMetadataElementConstructor);
2369static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGMissingGlyphElementConstructor);
2370static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGNumberConstructor);
2371static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGNumberListConstructor);
2372static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGPathElementConstructor);
2373static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegConstructor);
2374static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegArcAbsConstructor);
2375static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegArcRelConstructor);
2376static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegClosePathConstructor);
2377static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegCurvetoCubicAbsConstructor);
2378static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegCurvetoCubicRelConstructor);
2379static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegCurvetoCubicSmoothAbsConstructor);
2380static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegCurvetoCubicSmoothRelConstructor);
2381static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegCurvetoQuadraticAbsConstructor);
2382static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegCurvetoQuadraticRelConstructor);
2383static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegCurvetoQuadraticSmoothAbsConstructor);
2384static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegCurvetoQuadraticSmoothRelConstructor);
2385static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegLinetoAbsConstructor);
2386static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegLinetoHorizontalAbsConstructor);
2387static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegLinetoHorizontalRelConstructor);
2388static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegLinetoRelConstructor);
2389static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegLinetoVerticalAbsConstructor);
2390static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegLinetoVerticalRelConstructor);
2391static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegListConstructor);
2392static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegMovetoAbsConstructor);
2393static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegMovetoRelConstructor);
2394static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGPatternElementConstructor);
2395static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGPointConstructor);
2396static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGPointListConstructor);
2397static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGPolygonElementConstructor);
2398static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGPolylineElementConstructor);
2399static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGPreserveAspectRatioConstructor);
2400static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGRadialGradientElementConstructor);
2401static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGRectConstructor);
2402static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGRectElementConstructor);
2403static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGRenderingIntentConstructor);
2404static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGSVGElementConstructor);
2405static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGScriptElementConstructor);
2406static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGSetElementConstructor);
2407static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGStopElementConstructor);
2408static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGStringListConstructor);
2409static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGStyleElementConstructor);
2410static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGSwitchElementConstructor);
2411static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGSymbolElementConstructor);
2412static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGTRefElementConstructor);
2413static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGTSpanElementConstructor);
2414static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGTextContentElementConstructor);
2415static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGTextElementConstructor);
2416static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGTextPathElementConstructor);
2417static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGTextPositioningElementConstructor);
2418static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGTitleElementConstructor);
2419static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGTransformConstructor);
2420static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGTransformListConstructor);
2421static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGUnitTypesConstructor);
2422static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGUseElementConstructor);
2423static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGVKernElementConstructor);
2424static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGViewElementConstructor);
2425static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGViewSpecConstructor);
2426static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_SVGZoomEventConstructor);
2427static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WorkerConstructor);
2428#if ENABLE(SERVICE_WORKER)
2429static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ServiceWorkerConstructor);
2430#endif
2431#if ENABLE(SERVICE_WORKER)
2432static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ServiceWorkerContainerConstructor);
2433#endif
2434#if ENABLE(SERVICE_WORKER)
2435static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_ServiceWorkerRegistrationConstructor);
2436#endif
2437static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_WorkletConstructor);
2438static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_DOMParserConstructor);
2439static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_XMLHttpRequestConstructor);
2440static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_XMLHttpRequestEventTargetConstructor);
2441static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_XMLHttpRequestProgressEventConstructor);
2442static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_XMLHttpRequestUploadConstructor);
2443static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_XMLSerializerConstructor);
2444static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_XPathEvaluatorConstructor);
2445static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_XPathExpressionConstructor);
2446static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_XPathResultConstructor);
2447#if ENABLE(XSLT)
2448static JSC_DECLARE_CUSTOM_GETTER(jsDOMWindow_XSLTProcessorConstructor);
2449#endif
2450
2451using JSDOMWindowDOMConstructor = JSDOMConstructorNotConstructable<JSDOMWindow>;
2452
2453template<> const unsigned JSDOMWindowDOMConstructor::StructureFlags = Base::StructureFlags;
2454template<> const ClassInfo JSDOMWindowDOMConstructor::s_info = { "Window", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSDOMWindowDOMConstructor) };
2455
2456template<> JSValue JSDOMWindowDOMConstructor::prototypeForStructure(JSC::VM& vm, const JSDOMGlobalObject& globalObject)
2457{
2458 return JSEventTarget::getConstructor(vm, &globalObject);
2459}
2460
2461template<> void JSDOMWindowDOMConstructor::initializeProperties(VM& vm, JSDOMGlobalObject& globalObject)
2462{
2463 putDirect(vm, vm.propertyNames->prototype, globalObject.getPrototypeDirect(vm), JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
2464 putDirect(vm, vm.propertyNames->name, jsNontrivialString(vm, "Window"_s), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
2465 putDirect(vm, vm.propertyNames->length, jsNumber(0), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
2466}
2467
2468/* Hash table for Prototype */
2469
2470static const struct CompactHashIndex JSDOMWindowPrototypeTableIndex[2] = {
2471 { -1, -1 },
2472 { 0, -1 },
2473};
2474
2475
2476static const HashTableValue JSDOMWindowPrototypeTableValues[] =
2477{
2478 { "constructor", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindowConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
2479};
2480
2481static const HashTable JSDOMWindowPrototypeTable = { 1, 1, true, JSDOMWindow::info(), JSDOMWindowPrototypeTableValues, JSDOMWindowPrototypeTableIndex };
2482const ClassInfo JSDOMWindowPrototype::s_info = { "Window", &Base::s_info, &JSDOMWindowPrototypeTable, nullptr, CREATE_METHOD_TABLE(JSDOMWindowPrototype) };
2483
2484void JSDOMWindowPrototype::finishCreation(VM& vm)
2485{
2486 Base::finishCreation(vm);
2487 JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
2488}
2489
2490#if ENABLE(TOUCH_EVENTS)
2491static JSValue createJSDOMWindowInstance_ontouchcancel(VM& vm, JSObject*)
2492{
2493 return CustomGetterSetter::create(vm, jsDOMWindow_ontouchcancel, setJSDOMWindow_ontouchcancel);
2494}
2495
2496static bool isEnabledJSDOMWindowInstance_ontouchcancel(JSGlobalObject* globalObject)
2497{
2498 UNUSED_PARAM(globalObject);
2499 return RuntimeEnabledFeatures::sharedFeatures().touchEventsEnabled();
2500}
2501#endif
2502
2503#if ENABLE(TOUCH_EVENTS)
2504static JSValue createJSDOMWindowInstance_ontouchend(VM& vm, JSObject*)
2505{
2506 return CustomGetterSetter::create(vm, jsDOMWindow_ontouchend, setJSDOMWindow_ontouchend);
2507}
2508
2509static bool isEnabledJSDOMWindowInstance_ontouchend(JSGlobalObject* globalObject)
2510{
2511 UNUSED_PARAM(globalObject);
2512 return RuntimeEnabledFeatures::sharedFeatures().touchEventsEnabled();
2513}
2514#endif
2515
2516#if ENABLE(TOUCH_EVENTS)
2517static JSValue createJSDOMWindowInstance_ontouchmove(VM& vm, JSObject*)
2518{
2519 return CustomGetterSetter::create(vm, jsDOMWindow_ontouchmove, setJSDOMWindow_ontouchmove);
2520}
2521
2522static bool isEnabledJSDOMWindowInstance_ontouchmove(JSGlobalObject* globalObject)
2523{
2524 UNUSED_PARAM(globalObject);
2525 return RuntimeEnabledFeatures::sharedFeatures().touchEventsEnabled();
2526}
2527#endif
2528
2529#if ENABLE(TOUCH_EVENTS)
2530static JSValue createJSDOMWindowInstance_ontouchstart(VM& vm, JSObject*)
2531{
2532 return CustomGetterSetter::create(vm, jsDOMWindow_ontouchstart, setJSDOMWindow_ontouchstart);
2533}
2534
2535static bool isEnabledJSDOMWindowInstance_ontouchstart(JSGlobalObject* globalObject)
2536{
2537 UNUSED_PARAM(globalObject);
2538 return RuntimeEnabledFeatures::sharedFeatures().touchEventsEnabled();
2539}
2540#endif
2541
2542#if ENABLE(TOUCH_EVENTS)
2543static JSValue createJSDOMWindowInstance_ontouchforcechange(VM& vm, JSObject*)
2544{
2545 return CustomGetterSetter::create(vm, jsDOMWindow_ontouchforcechange, setJSDOMWindow_ontouchforcechange);
2546}
2547
2548static bool isEnabledJSDOMWindowInstance_ontouchforcechange(JSGlobalObject* globalObject)
2549{
2550 UNUSED_PARAM(globalObject);
2551 return RuntimeEnabledFeatures::sharedFeatures().touchEventsEnabled();
2552}
2553#endif
2554
2555static JSValue createJSDOMWindowInstance_visualViewport(VM& vm, JSObject*)
2556{
2557 return CustomGetterSetter::create(vm, jsDOMWindow_visualViewport, setJSDOMWindow_visualViewport);
2558}
2559
2560static bool isEnabledJSDOMWindowInstance_visualViewport(JSGlobalObject* globalObject)
2561{
2562 UNUSED_PARAM(globalObject);
2563 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().visualViewportAPIEnabled;
2564}
2565
2566static JSValue createJSDOMWindowInstance_caches(VM& vm, JSObject*)
2567{
2568 return CustomGetterSetter::create(vm, jsDOMWindow_caches, nullptr);
2569}
2570
2571static bool isEnabledJSDOMWindowInstance_caches(JSGlobalObject* globalObject)
2572{
2573 UNUSED_PARAM(globalObject);
2574 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && RuntimeEnabledFeatures::sharedFeatures().cacheAPIEnabled());
2575}
2576
2577#if ENABLE(APPLE_PAY)
2578static JSValue createJSDOMWindowInstance_ApplePaySession(VM& vm, JSObject*)
2579{
2580 return CustomGetterSetter::create(vm, jsDOMWindow_ApplePaySessionConstructor, nullptr);
2581}
2582
2583static bool isEnabledJSDOMWindowInstance_ApplePaySession(JSGlobalObject* globalObject)
2584{
2585 UNUSED_PARAM(globalObject);
2586 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().applePayEnabled && ApplePaySession::enabledForContext(*jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()));
2587}
2588#endif
2589
2590#if ENABLE(APPLE_PAY)
2591static JSValue createJSDOMWindowInstance_ApplePaySetup(VM& vm, JSObject*)
2592{
2593 return CustomGetterSetter::create(vm, jsDOMWindow_ApplePaySetupConstructor, nullptr);
2594}
2595
2596static bool isEnabledJSDOMWindowInstance_ApplePaySetup(JSGlobalObject* globalObject)
2597{
2598 UNUSED_PARAM(globalObject);
2599 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().applePayEnabled);
2600}
2601#endif
2602
2603#if ENABLE(APPLE_PAY)
2604static JSValue createJSDOMWindowInstance_ApplePaySetupFeature(VM& vm, JSObject*)
2605{
2606 return CustomGetterSetter::create(vm, jsDOMWindow_ApplePaySetupFeatureConstructor, nullptr);
2607}
2608
2609static bool isEnabledJSDOMWindowInstance_ApplePaySetupFeature(JSGlobalObject* globalObject)
2610{
2611 UNUSED_PARAM(globalObject);
2612 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().applePayEnabled);
2613}
2614#endif
2615
2616static JSValue createJSDOMWindowInstance_Clipboard(VM& vm, JSObject*)
2617{
2618 return CustomGetterSetter::create(vm, jsDOMWindow_ClipboardConstructor, nullptr);
2619}
2620
2621static bool isEnabledJSDOMWindowInstance_Clipboard(JSGlobalObject* globalObject)
2622{
2623 UNUSED_PARAM(globalObject);
2624 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().asyncClipboardAPIEnabled);
2625}
2626
2627static JSValue createJSDOMWindowInstance_ClipboardItem(VM& vm, JSObject*)
2628{
2629 return CustomGetterSetter::create(vm, jsDOMWindow_ClipboardItemConstructor, nullptr);
2630}
2631
2632static bool isEnabledJSDOMWindowInstance_ClipboardItem(JSGlobalObject* globalObject)
2633{
2634 UNUSED_PARAM(globalObject);
2635 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().asyncClipboardAPIEnabled;
2636}
2637
2638static JSValue createJSDOMWindowInstance_Cache(VM& vm, JSObject*)
2639{
2640 return CustomGetterSetter::create(vm, jsDOMWindow_CacheConstructor, nullptr);
2641}
2642
2643static bool isEnabledJSDOMWindowInstance_Cache(JSGlobalObject* globalObject)
2644{
2645 UNUSED_PARAM(globalObject);
2646 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && RuntimeEnabledFeatures::sharedFeatures().cacheAPIEnabled());
2647}
2648
2649static JSValue createJSDOMWindowInstance_CacheStorage(VM& vm, JSObject*)
2650{
2651 return CustomGetterSetter::create(vm, jsDOMWindow_CacheStorageConstructor, nullptr);
2652}
2653
2654static bool isEnabledJSDOMWindowInstance_CacheStorage(JSGlobalObject* globalObject)
2655{
2656 UNUSED_PARAM(globalObject);
2657 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && RuntimeEnabledFeatures::sharedFeatures().cacheAPIEnabled());
2658}
2659
2660static JSValue createJSDOMWindowInstance_ContactsManager(VM& vm, JSObject*)
2661{
2662 return CustomGetterSetter::create(vm, jsDOMWindow_ContactsManagerConstructor, nullptr);
2663}
2664
2665static bool isEnabledJSDOMWindowInstance_ContactsManager(JSGlobalObject* globalObject)
2666{
2667 UNUSED_PARAM(globalObject);
2668 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().contactPickerAPIEnabled);
2669}
2670
2671#if ENABLE(WEB_AUTHN)
2672static JSValue createJSDOMWindowInstance_Credential(VM& vm, JSObject*)
2673{
2674 return CustomGetterSetter::create(vm, jsDOMWindow_CredentialConstructor, nullptr);
2675}
2676
2677static bool isEnabledJSDOMWindowInstance_Credential(JSGlobalObject* globalObject)
2678{
2679 UNUSED_PARAM(globalObject);
2680 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webAuthenticationEnabled);
2681}
2682#endif
2683
2684#if ENABLE(WEB_AUTHN)
2685static JSValue createJSDOMWindowInstance_CredentialsContainer(VM& vm, JSObject*)
2686{
2687 return CustomGetterSetter::create(vm, jsDOMWindow_CredentialsContainerConstructor, nullptr);
2688}
2689
2690static bool isEnabledJSDOMWindowInstance_CredentialsContainer(JSGlobalObject* globalObject)
2691{
2692 UNUSED_PARAM(globalObject);
2693 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webAuthenticationEnabled);
2694}
2695#endif
2696
2697#if ENABLE(ENCRYPTED_MEDIA)
2698static JSValue createJSDOMWindowInstance_MediaKeyMessageEvent(VM& vm, JSObject*)
2699{
2700 return CustomGetterSetter::create(vm, jsDOMWindow_MediaKeyMessageEventConstructor, nullptr);
2701}
2702
2703static bool isEnabledJSDOMWindowInstance_MediaKeyMessageEvent(JSGlobalObject* globalObject)
2704{
2705 UNUSED_PARAM(globalObject);
2706 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().encryptedMediaAPIEnabled && !downcast<Document>(jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext())->quirks().hasBrokenEncryptedMediaAPISupportQuirk());
2707}
2708#endif
2709
2710#if ENABLE(ENCRYPTED_MEDIA)
2711static JSValue createJSDOMWindowInstance_MediaKeySession(VM& vm, JSObject*)
2712{
2713 return CustomGetterSetter::create(vm, jsDOMWindow_MediaKeySessionConstructor, nullptr);
2714}
2715
2716static bool isEnabledJSDOMWindowInstance_MediaKeySession(JSGlobalObject* globalObject)
2717{
2718 UNUSED_PARAM(globalObject);
2719 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().encryptedMediaAPIEnabled && !downcast<Document>(jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext())->quirks().hasBrokenEncryptedMediaAPISupportQuirk());
2720}
2721#endif
2722
2723#if ENABLE(ENCRYPTED_MEDIA)
2724static JSValue createJSDOMWindowInstance_MediaKeyStatusMap(VM& vm, JSObject*)
2725{
2726 return CustomGetterSetter::create(vm, jsDOMWindow_MediaKeyStatusMapConstructor, nullptr);
2727}
2728
2729static bool isEnabledJSDOMWindowInstance_MediaKeyStatusMap(JSGlobalObject* globalObject)
2730{
2731 UNUSED_PARAM(globalObject);
2732 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().encryptedMediaAPIEnabled && !downcast<Document>(jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext())->quirks().hasBrokenEncryptedMediaAPISupportQuirk());
2733}
2734#endif
2735
2736#if ENABLE(ENCRYPTED_MEDIA)
2737static JSValue createJSDOMWindowInstance_MediaKeySystemAccess(VM& vm, JSObject*)
2738{
2739 return CustomGetterSetter::create(vm, jsDOMWindow_MediaKeySystemAccessConstructor, nullptr);
2740}
2741
2742static bool isEnabledJSDOMWindowInstance_MediaKeySystemAccess(JSGlobalObject* globalObject)
2743{
2744 UNUSED_PARAM(globalObject);
2745 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().encryptedMediaAPIEnabled && !downcast<Document>(jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext())->quirks().hasBrokenEncryptedMediaAPISupportQuirk());
2746}
2747#endif
2748
2749#if ENABLE(ENCRYPTED_MEDIA)
2750static JSValue createJSDOMWindowInstance_MediaKeys(VM& vm, JSObject*)
2751{
2752 return CustomGetterSetter::create(vm, jsDOMWindow_MediaKeysConstructor, nullptr);
2753}
2754
2755static bool isEnabledJSDOMWindowInstance_MediaKeys(JSGlobalObject* globalObject)
2756{
2757 UNUSED_PARAM(globalObject);
2758 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().encryptedMediaAPIEnabled && !downcast<Document>(jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext())->quirks().hasBrokenEncryptedMediaAPISupportQuirk());
2759}
2760#endif
2761
2762#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
2763static JSValue createJSDOMWindowInstance_WebKitMediaKeyMessageEvent(VM& vm, JSObject*)
2764{
2765 return CustomGetterSetter::create(vm, jsDOMWindow_WebKitMediaKeyMessageEventConstructor, nullptr);
2766}
2767
2768static bool isEnabledJSDOMWindowInstance_WebKitMediaKeyMessageEvent(JSGlobalObject* globalObject)
2769{
2770 UNUSED_PARAM(globalObject);
2771 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().legacyEncryptedMediaAPIEnabled;
2772}
2773#endif
2774
2775#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
2776static JSValue createJSDOMWindowInstance_WebKitMediaKeyNeededEvent(VM& vm, JSObject*)
2777{
2778 return CustomGetterSetter::create(vm, jsDOMWindow_WebKitMediaKeyNeededEventConstructor, nullptr);
2779}
2780
2781static bool isEnabledJSDOMWindowInstance_WebKitMediaKeyNeededEvent(JSGlobalObject* globalObject)
2782{
2783 UNUSED_PARAM(globalObject);
2784 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().legacyEncryptedMediaAPIEnabled;
2785}
2786#endif
2787
2788#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
2789static JSValue createJSDOMWindowInstance_WebKitMediaKeySession(VM& vm, JSObject*)
2790{
2791 return CustomGetterSetter::create(vm, jsDOMWindow_WebKitMediaKeySessionConstructor, nullptr);
2792}
2793
2794static bool isEnabledJSDOMWindowInstance_WebKitMediaKeySession(JSGlobalObject* globalObject)
2795{
2796 UNUSED_PARAM(globalObject);
2797 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().legacyEncryptedMediaAPIEnabled;
2798}
2799#endif
2800
2801#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
2802static JSValue createJSDOMWindowInstance_WebKitMediaKeys(VM& vm, JSObject*)
2803{
2804 return CustomGetterSetter::create(vm, jsDOMWindow_WebKitMediaKeysConstructor, nullptr);
2805}
2806
2807static bool isEnabledJSDOMWindowInstance_WebKitMediaKeys(JSGlobalObject* globalObject)
2808{
2809 UNUSED_PARAM(globalObject);
2810 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().legacyEncryptedMediaAPIEnabled;
2811}
2812#endif
2813
2814static JSValue createJSDOMWindowInstance_FileSystem(VM& vm, JSObject*)
2815{
2816 return CustomGetterSetter::create(vm, jsDOMWindow_FileSystemConstructor, nullptr);
2817}
2818
2819static bool isEnabledJSDOMWindowInstance_FileSystem(JSGlobalObject* globalObject)
2820{
2821 UNUSED_PARAM(globalObject);
2822 return RuntimeEnabledFeatures::sharedFeatures().directoryUploadEnabled();
2823}
2824
2825static JSValue createJSDOMWindowInstance_FileSystemDirectoryEntry(VM& vm, JSObject*)
2826{
2827 return CustomGetterSetter::create(vm, jsDOMWindow_FileSystemDirectoryEntryConstructor, nullptr);
2828}
2829
2830static bool isEnabledJSDOMWindowInstance_FileSystemDirectoryEntry(JSGlobalObject* globalObject)
2831{
2832 UNUSED_PARAM(globalObject);
2833 return RuntimeEnabledFeatures::sharedFeatures().directoryUploadEnabled();
2834}
2835
2836static JSValue createJSDOMWindowInstance_FileSystemDirectoryReader(VM& vm, JSObject*)
2837{
2838 return CustomGetterSetter::create(vm, jsDOMWindow_FileSystemDirectoryReaderConstructor, nullptr);
2839}
2840
2841static bool isEnabledJSDOMWindowInstance_FileSystemDirectoryReader(JSGlobalObject* globalObject)
2842{
2843 UNUSED_PARAM(globalObject);
2844 return RuntimeEnabledFeatures::sharedFeatures().directoryUploadEnabled();
2845}
2846
2847static JSValue createJSDOMWindowInstance_FileSystemEntry(VM& vm, JSObject*)
2848{
2849 return CustomGetterSetter::create(vm, jsDOMWindow_FileSystemEntryConstructor, nullptr);
2850}
2851
2852static bool isEnabledJSDOMWindowInstance_FileSystemEntry(JSGlobalObject* globalObject)
2853{
2854 UNUSED_PARAM(globalObject);
2855 return RuntimeEnabledFeatures::sharedFeatures().directoryUploadEnabled();
2856}
2857
2858static JSValue createJSDOMWindowInstance_FileSystemFileEntry(VM& vm, JSObject*)
2859{
2860 return CustomGetterSetter::create(vm, jsDOMWindow_FileSystemFileEntryConstructor, nullptr);
2861}
2862
2863static bool isEnabledJSDOMWindowInstance_FileSystemFileEntry(JSGlobalObject* globalObject)
2864{
2865 UNUSED_PARAM(globalObject);
2866 return RuntimeEnabledFeatures::sharedFeatures().directoryUploadEnabled();
2867}
2868
2869#if ENABLE(GAMEPAD)
2870static JSValue createJSDOMWindowInstance_Gamepad(VM& vm, JSObject*)
2871{
2872 return CustomGetterSetter::create(vm, jsDOMWindow_GamepadConstructor, nullptr);
2873}
2874
2875static bool isEnabledJSDOMWindowInstance_Gamepad(JSGlobalObject* globalObject)
2876{
2877 UNUSED_PARAM(globalObject);
2878 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().gamepadsEnabled;
2879}
2880#endif
2881
2882#if ENABLE(GAMEPAD)
2883static JSValue createJSDOMWindowInstance_GamepadButton(VM& vm, JSObject*)
2884{
2885 return CustomGetterSetter::create(vm, jsDOMWindow_GamepadButtonConstructor, nullptr);
2886}
2887
2888static bool isEnabledJSDOMWindowInstance_GamepadButton(JSGlobalObject* globalObject)
2889{
2890 UNUSED_PARAM(globalObject);
2891 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().gamepadsEnabled;
2892}
2893#endif
2894
2895#if ENABLE(GAMEPAD)
2896static JSValue createJSDOMWindowInstance_GamepadEvent(VM& vm, JSObject*)
2897{
2898 return CustomGetterSetter::create(vm, jsDOMWindow_GamepadEventConstructor, nullptr);
2899}
2900
2901static bool isEnabledJSDOMWindowInstance_GamepadEvent(JSGlobalObject* globalObject)
2902{
2903 UNUSED_PARAM(globalObject);
2904 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().gamepadsEnabled;
2905}
2906#endif
2907
2908static JSValue createJSDOMWindowInstance_Highlight(VM& vm, JSObject*)
2909{
2910 return CustomGetterSetter::create(vm, jsDOMWindow_HighlightConstructor, nullptr);
2911}
2912
2913static bool isEnabledJSDOMWindowInstance_Highlight(JSGlobalObject* globalObject)
2914{
2915 UNUSED_PARAM(globalObject);
2916 return RuntimeEnabledFeatures::sharedFeatures().highlightAPIEnabled();
2917}
2918
2919static JSValue createJSDOMWindowInstance_HighlightRegister(VM& vm, JSObject*)
2920{
2921 return CustomGetterSetter::create(vm, jsDOMWindow_HighlightRegisterConstructor, nullptr);
2922}
2923
2924static bool isEnabledJSDOMWindowInstance_HighlightRegister(JSGlobalObject* globalObject)
2925{
2926 UNUSED_PARAM(globalObject);
2927 return RuntimeEnabledFeatures::sharedFeatures().highlightAPIEnabled();
2928}
2929
2930static JSValue createJSDOMWindowInstance_MediaCapabilities(VM& vm, JSObject*)
2931{
2932 return CustomGetterSetter::create(vm, jsDOMWindow_MediaCapabilitiesConstructor, nullptr);
2933}
2934
2935static bool isEnabledJSDOMWindowInstance_MediaCapabilities(JSGlobalObject* globalObject)
2936{
2937 UNUSED_PARAM(globalObject);
2938 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().mediaCapabilitiesEnabled;
2939}
2940
2941#if ENABLE(MEDIA_STREAM)
2942static JSValue createJSDOMWindowInstance_BlobEvent(VM& vm, JSObject*)
2943{
2944 return CustomGetterSetter::create(vm, jsDOMWindow_BlobEventConstructor, nullptr);
2945}
2946
2947static bool isEnabledJSDOMWindowInstance_BlobEvent(JSGlobalObject* globalObject)
2948{
2949 UNUSED_PARAM(globalObject);
2950 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().mediaRecorderEnabled;
2951}
2952#endif
2953
2954#if ENABLE(MEDIA_STREAM)
2955static JSValue createJSDOMWindowInstance_MediaRecorder(VM& vm, JSObject*)
2956{
2957 return CustomGetterSetter::create(vm, jsDOMWindow_MediaRecorderConstructor, nullptr);
2958}
2959
2960static bool isEnabledJSDOMWindowInstance_MediaRecorder(JSGlobalObject* globalObject)
2961{
2962 UNUSED_PARAM(globalObject);
2963 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().mediaRecorderEnabled;
2964}
2965#endif
2966
2967#if ENABLE(MEDIA_STREAM)
2968static JSValue createJSDOMWindowInstance_MediaRecorderErrorEvent(VM& vm, JSObject*)
2969{
2970 return CustomGetterSetter::create(vm, jsDOMWindow_MediaRecorderErrorEventConstructor, nullptr);
2971}
2972
2973static bool isEnabledJSDOMWindowInstance_MediaRecorderErrorEvent(JSGlobalObject* globalObject)
2974{
2975 UNUSED_PARAM(globalObject);
2976 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().mediaRecorderEnabled;
2977}
2978#endif
2979
2980#if ENABLE(MEDIA_SESSION_COORDINATOR)
2981static JSValue createJSDOMWindowInstance_MediaSessionCoordinator(VM& vm, JSObject*)
2982{
2983 return CustomGetterSetter::create(vm, jsDOMWindow_MediaSessionCoordinatorConstructor, nullptr);
2984}
2985
2986static bool isEnabledJSDOMWindowInstance_MediaSessionCoordinator(JSGlobalObject* globalObject)
2987{
2988 UNUSED_PARAM(globalObject);
2989 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().mediaSessionCoordinatorEnabled;
2990}
2991#endif
2992
2993#if ENABLE(MEDIA_SOURCE)
2994static JSValue createJSDOMWindowInstance_MediaSource(VM& vm, JSObject*)
2995{
2996 return CustomGetterSetter::create(vm, jsDOMWindow_MediaSourceConstructor, nullptr);
2997}
2998
2999static bool isEnabledJSDOMWindowInstance_MediaSource(JSGlobalObject* globalObject)
3000{
3001 UNUSED_PARAM(globalObject);
3002 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().mediaSourceEnabled;
3003}
3004#endif
3005
3006#if ENABLE(MEDIA_SOURCE)
3007static JSValue createJSDOMWindowInstance_SourceBuffer(VM& vm, JSObject*)
3008{
3009 return CustomGetterSetter::create(vm, jsDOMWindow_SourceBufferConstructor, nullptr);
3010}
3011
3012static bool isEnabledJSDOMWindowInstance_SourceBuffer(JSGlobalObject* globalObject)
3013{
3014 UNUSED_PARAM(globalObject);
3015 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().mediaSourceEnabled;
3016}
3017#endif
3018
3019#if ENABLE(MEDIA_SOURCE)
3020static JSValue createJSDOMWindowInstance_SourceBufferList(VM& vm, JSObject*)
3021{
3022 return CustomGetterSetter::create(vm, jsDOMWindow_SourceBufferListConstructor, nullptr);
3023}
3024
3025static bool isEnabledJSDOMWindowInstance_SourceBufferList(JSGlobalObject* globalObject)
3026{
3027 UNUSED_PARAM(globalObject);
3028 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().mediaSourceEnabled;
3029}
3030#endif
3031
3032#if ENABLE(MEDIA_STREAM)
3033static JSValue createJSDOMWindowInstance_MediaDevices(VM& vm, JSObject*)
3034{
3035 return CustomGetterSetter::create(vm, jsDOMWindow_MediaDevicesConstructor, nullptr);
3036}
3037
3038static bool isEnabledJSDOMWindowInstance_MediaDevices(JSGlobalObject* globalObject)
3039{
3040 UNUSED_PARAM(globalObject);
3041 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext();
3042}
3043#endif
3044
3045#if ENABLE(WEB_RTC)
3046static JSValue createJSDOMWindowInstance_RTCCertificate(VM& vm, JSObject*)
3047{
3048 return CustomGetterSetter::create(vm, jsDOMWindow_RTCCertificateConstructor, nullptr);
3049}
3050
3051static bool isEnabledJSDOMWindowInstance_RTCCertificate(JSGlobalObject* globalObject)
3052{
3053 UNUSED_PARAM(globalObject);
3054 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().peerConnectionEnabled;
3055}
3056#endif
3057
3058#if ENABLE(WEB_RTC)
3059static JSValue createJSDOMWindowInstance_RTCDTMFSender(VM& vm, JSObject*)
3060{
3061 return CustomGetterSetter::create(vm, jsDOMWindow_RTCDTMFSenderConstructor, nullptr);
3062}
3063
3064static bool isEnabledJSDOMWindowInstance_RTCDTMFSender(JSGlobalObject* globalObject)
3065{
3066 UNUSED_PARAM(globalObject);
3067 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().peerConnectionEnabled;
3068}
3069#endif
3070
3071#if ENABLE(WEB_RTC)
3072static JSValue createJSDOMWindowInstance_RTCDTMFToneChangeEvent(VM& vm, JSObject*)
3073{
3074 return CustomGetterSetter::create(vm, jsDOMWindow_RTCDTMFToneChangeEventConstructor, nullptr);
3075}
3076
3077static bool isEnabledJSDOMWindowInstance_RTCDTMFToneChangeEvent(JSGlobalObject* globalObject)
3078{
3079 UNUSED_PARAM(globalObject);
3080 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().peerConnectionEnabled;
3081}
3082#endif
3083
3084#if ENABLE(WEB_RTC)
3085static JSValue createJSDOMWindowInstance_RTCDataChannel(VM& vm, JSObject*)
3086{
3087 return CustomGetterSetter::create(vm, jsDOMWindow_RTCDataChannelConstructor, nullptr);
3088}
3089
3090static bool isEnabledJSDOMWindowInstance_RTCDataChannel(JSGlobalObject* globalObject)
3091{
3092 UNUSED_PARAM(globalObject);
3093 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().peerConnectionEnabled;
3094}
3095#endif
3096
3097#if ENABLE(WEB_RTC)
3098static JSValue createJSDOMWindowInstance_RTCDataChannelEvent(VM& vm, JSObject*)
3099{
3100 return CustomGetterSetter::create(vm, jsDOMWindow_RTCDataChannelEventConstructor, nullptr);
3101}
3102
3103static bool isEnabledJSDOMWindowInstance_RTCDataChannelEvent(JSGlobalObject* globalObject)
3104{
3105 UNUSED_PARAM(globalObject);
3106 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().peerConnectionEnabled;
3107}
3108#endif
3109
3110#if ENABLE(WEB_RTC)
3111static JSValue createJSDOMWindowInstance_RTCIceCandidate(VM& vm, JSObject*)
3112{
3113 return CustomGetterSetter::create(vm, jsDOMWindow_RTCIceCandidateConstructor, nullptr);
3114}
3115
3116static bool isEnabledJSDOMWindowInstance_RTCIceCandidate(JSGlobalObject* globalObject)
3117{
3118 UNUSED_PARAM(globalObject);
3119 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().peerConnectionEnabled;
3120}
3121#endif
3122
3123#if ENABLE(WEB_RTC)
3124static JSValue createJSDOMWindowInstance_RTCIceTransport(VM& vm, JSObject*)
3125{
3126 return CustomGetterSetter::create(vm, jsDOMWindow_RTCIceTransportConstructor, nullptr);
3127}
3128
3129static bool isEnabledJSDOMWindowInstance_RTCIceTransport(JSGlobalObject* globalObject)
3130{
3131 UNUSED_PARAM(globalObject);
3132 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().peerConnectionEnabled;
3133}
3134#endif
3135
3136#if ENABLE(WEB_RTC)
3137static JSValue createJSDOMWindowInstance_RTCPeerConnection(VM& vm, JSObject*)
3138{
3139 return CustomGetterSetter::create(vm, jsDOMWindow_RTCPeerConnectionConstructor, nullptr);
3140}
3141
3142static bool isEnabledJSDOMWindowInstance_RTCPeerConnection(JSGlobalObject* globalObject)
3143{
3144 UNUSED_PARAM(globalObject);
3145 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().peerConnectionEnabled;
3146}
3147#endif
3148
3149#if ENABLE(WEB_RTC)
3150static JSValue createJSDOMWindowInstance_RTCPeerConnectionIceErrorEvent(VM& vm, JSObject*)
3151{
3152 return CustomGetterSetter::create(vm, jsDOMWindow_RTCPeerConnectionIceErrorEventConstructor, nullptr);
3153}
3154
3155static bool isEnabledJSDOMWindowInstance_RTCPeerConnectionIceErrorEvent(JSGlobalObject* globalObject)
3156{
3157 UNUSED_PARAM(globalObject);
3158 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().peerConnectionEnabled;
3159}
3160#endif
3161
3162#if ENABLE(WEB_RTC)
3163static JSValue createJSDOMWindowInstance_RTCPeerConnectionIceEvent(VM& vm, JSObject*)
3164{
3165 return CustomGetterSetter::create(vm, jsDOMWindow_RTCPeerConnectionIceEventConstructor, nullptr);
3166}
3167
3168static bool isEnabledJSDOMWindowInstance_RTCPeerConnectionIceEvent(JSGlobalObject* globalObject)
3169{
3170 UNUSED_PARAM(globalObject);
3171 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().peerConnectionEnabled;
3172}
3173#endif
3174
3175#if ENABLE(WEB_RTC)
3176static JSValue createJSDOMWindowInstance_RTCRtpReceiver(VM& vm, JSObject*)
3177{
3178 return CustomGetterSetter::create(vm, jsDOMWindow_RTCRtpReceiverConstructor, nullptr);
3179}
3180
3181static bool isEnabledJSDOMWindowInstance_RTCRtpReceiver(JSGlobalObject* globalObject)
3182{
3183 UNUSED_PARAM(globalObject);
3184 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().peerConnectionEnabled;
3185}
3186#endif
3187
3188#if ENABLE(WEB_RTC)
3189static JSValue createJSDOMWindowInstance_SFrameTransform(VM& vm, JSObject*)
3190{
3191 return CustomGetterSetter::create(vm, jsDOMWindow_SFrameTransformConstructor, nullptr);
3192}
3193
3194static bool isEnabledJSDOMWindowInstance_SFrameTransform(JSGlobalObject* globalObject)
3195{
3196 UNUSED_PARAM(globalObject);
3197 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webRTCInsertableStreamsEnabled;
3198}
3199#endif
3200
3201#if ENABLE(WEB_RTC)
3202static JSValue createJSDOMWindowInstance_RTCRtpScriptTransform(VM& vm, JSObject*)
3203{
3204 return CustomGetterSetter::create(vm, jsDOMWindow_RTCRtpScriptTransformConstructor, nullptr);
3205}
3206
3207static bool isEnabledJSDOMWindowInstance_RTCRtpScriptTransform(JSGlobalObject* globalObject)
3208{
3209 UNUSED_PARAM(globalObject);
3210 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webRTCInsertableStreamsEnabled;
3211}
3212#endif
3213
3214#if ENABLE(WEB_RTC)
3215static JSValue createJSDOMWindowInstance_RTCRtpSender(VM& vm, JSObject*)
3216{
3217 return CustomGetterSetter::create(vm, jsDOMWindow_RTCRtpSenderConstructor, nullptr);
3218}
3219
3220static bool isEnabledJSDOMWindowInstance_RTCRtpSender(JSGlobalObject* globalObject)
3221{
3222 UNUSED_PARAM(globalObject);
3223 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().peerConnectionEnabled;
3224}
3225#endif
3226
3227#if ENABLE(WEB_RTC)
3228static JSValue createJSDOMWindowInstance_RTCRtpTransceiver(VM& vm, JSObject*)
3229{
3230 return CustomGetterSetter::create(vm, jsDOMWindow_RTCRtpTransceiverConstructor, nullptr);
3231}
3232
3233static bool isEnabledJSDOMWindowInstance_RTCRtpTransceiver(JSGlobalObject* globalObject)
3234{
3235 UNUSED_PARAM(globalObject);
3236 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().peerConnectionEnabled;
3237}
3238#endif
3239
3240#if ENABLE(WEB_RTC)
3241static JSValue createJSDOMWindowInstance_RTCSessionDescription(VM& vm, JSObject*)
3242{
3243 return CustomGetterSetter::create(vm, jsDOMWindow_RTCSessionDescriptionConstructor, nullptr);
3244}
3245
3246static bool isEnabledJSDOMWindowInstance_RTCSessionDescription(JSGlobalObject* globalObject)
3247{
3248 UNUSED_PARAM(globalObject);
3249 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().peerConnectionEnabled;
3250}
3251#endif
3252
3253#if ENABLE(WEB_RTC)
3254static JSValue createJSDOMWindowInstance_RTCStatsReport(VM& vm, JSObject*)
3255{
3256 return CustomGetterSetter::create(vm, jsDOMWindow_RTCStatsReportConstructor, nullptr);
3257}
3258
3259static bool isEnabledJSDOMWindowInstance_RTCStatsReport(JSGlobalObject* globalObject)
3260{
3261 UNUSED_PARAM(globalObject);
3262 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().peerConnectionEnabled;
3263}
3264#endif
3265
3266#if ENABLE(WEB_RTC)
3267static JSValue createJSDOMWindowInstance_RTCTrackEvent(VM& vm, JSObject*)
3268{
3269 return CustomGetterSetter::create(vm, jsDOMWindow_RTCTrackEventConstructor, nullptr);
3270}
3271
3272static bool isEnabledJSDOMWindowInstance_RTCTrackEvent(JSGlobalObject* globalObject)
3273{
3274 UNUSED_PARAM(globalObject);
3275 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().peerConnectionEnabled;
3276}
3277#endif
3278
3279#if ENABLE(MODEL_ELEMENT)
3280static JSValue createJSDOMWindowInstance_HTMLModelElement(VM& vm, JSObject*)
3281{
3282 return CustomGetterSetter::create(vm, jsDOMWindow_HTMLModelElementConstructor, nullptr);
3283}
3284
3285static bool isEnabledJSDOMWindowInstance_HTMLModelElement(JSGlobalObject* globalObject)
3286{
3287 UNUSED_PARAM(globalObject);
3288 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().modelElementEnabled;
3289}
3290#endif
3291
3292#if ENABLE(PAYMENT_REQUEST)
3293static JSValue createJSDOMWindowInstance_MerchantValidationEvent(VM& vm, JSObject*)
3294{
3295 return CustomGetterSetter::create(vm, jsDOMWindow_MerchantValidationEventConstructor, nullptr);
3296}
3297
3298static bool isEnabledJSDOMWindowInstance_MerchantValidationEvent(JSGlobalObject* globalObject)
3299{
3300 UNUSED_PARAM(globalObject);
3301 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().paymentRequestEnabled);
3302}
3303#endif
3304
3305#if ENABLE(PAYMENT_REQUEST)
3306static JSValue createJSDOMWindowInstance_PaymentAddress(VM& vm, JSObject*)
3307{
3308 return CustomGetterSetter::create(vm, jsDOMWindow_PaymentAddressConstructor, nullptr);
3309}
3310
3311static bool isEnabledJSDOMWindowInstance_PaymentAddress(JSGlobalObject* globalObject)
3312{
3313 UNUSED_PARAM(globalObject);
3314 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().paymentRequestEnabled);
3315}
3316#endif
3317
3318#if ENABLE(PAYMENT_REQUEST)
3319static JSValue createJSDOMWindowInstance_PaymentMethodChangeEvent(VM& vm, JSObject*)
3320{
3321 return CustomGetterSetter::create(vm, jsDOMWindow_PaymentMethodChangeEventConstructor, nullptr);
3322}
3323
3324static bool isEnabledJSDOMWindowInstance_PaymentMethodChangeEvent(JSGlobalObject* globalObject)
3325{
3326 UNUSED_PARAM(globalObject);
3327 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().paymentRequestEnabled);
3328}
3329#endif
3330
3331#if ENABLE(PAYMENT_REQUEST)
3332static JSValue createJSDOMWindowInstance_PaymentRequest(VM& vm, JSObject*)
3333{
3334 return CustomGetterSetter::create(vm, jsDOMWindow_PaymentRequestConstructor, nullptr);
3335}
3336
3337static bool isEnabledJSDOMWindowInstance_PaymentRequest(JSGlobalObject* globalObject)
3338{
3339 UNUSED_PARAM(globalObject);
3340 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().paymentRequestEnabled && PaymentRequest::enabledForContext(*jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()));
3341}
3342#endif
3343
3344#if ENABLE(PAYMENT_REQUEST)
3345static JSValue createJSDOMWindowInstance_PaymentRequestUpdateEvent(VM& vm, JSObject*)
3346{
3347 return CustomGetterSetter::create(vm, jsDOMWindow_PaymentRequestUpdateEventConstructor, nullptr);
3348}
3349
3350static bool isEnabledJSDOMWindowInstance_PaymentRequestUpdateEvent(JSGlobalObject* globalObject)
3351{
3352 UNUSED_PARAM(globalObject);
3353 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().paymentRequestEnabled);
3354}
3355#endif
3356
3357#if ENABLE(PAYMENT_REQUEST)
3358static JSValue createJSDOMWindowInstance_PaymentResponse(VM& vm, JSObject*)
3359{
3360 return CustomGetterSetter::create(vm, jsDOMWindow_PaymentResponseConstructor, nullptr);
3361}
3362
3363static bool isEnabledJSDOMWindowInstance_PaymentResponse(JSGlobalObject* globalObject)
3364{
3365 UNUSED_PARAM(globalObject);
3366 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().paymentRequestEnabled);
3367}
3368#endif
3369
3370#if ENABLE(PICTURE_IN_PICTURE_API)
3371static JSValue createJSDOMWindowInstance_EnterPictureInPictureEvent(VM& vm, JSObject*)
3372{
3373 return CustomGetterSetter::create(vm, jsDOMWindow_EnterPictureInPictureEventConstructor, nullptr);
3374}
3375
3376static bool isEnabledJSDOMWindowInstance_EnterPictureInPictureEvent(JSGlobalObject* globalObject)
3377{
3378 UNUSED_PARAM(globalObject);
3379 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().pictureInPictureAPIEnabled;
3380}
3381#endif
3382
3383#if ENABLE(PICTURE_IN_PICTURE_API)
3384static JSValue createJSDOMWindowInstance_PictureInPictureWindow(VM& vm, JSObject*)
3385{
3386 return CustomGetterSetter::create(vm, jsDOMWindow_PictureInPictureWindowConstructor, nullptr);
3387}
3388
3389static bool isEnabledJSDOMWindowInstance_PictureInPictureWindow(JSGlobalObject* globalObject)
3390{
3391 UNUSED_PARAM(globalObject);
3392 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().pictureInPictureAPIEnabled;
3393}
3394#endif
3395
3396#if ENABLE(WIRELESS_PLAYBACK_TARGET)
3397static JSValue createJSDOMWindowInstance_RemotePlayback(VM& vm, JSObject*)
3398{
3399 return CustomGetterSetter::create(vm, jsDOMWindow_RemotePlaybackConstructor, nullptr);
3400}
3401
3402static bool isEnabledJSDOMWindowInstance_RemotePlayback(JSGlobalObject* globalObject)
3403{
3404 UNUSED_PARAM(globalObject);
3405 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().remotePlaybackEnabled;
3406}
3407#endif
3408
3409static JSValue createJSDOMWindowInstance_webkitSpeechRecognition(VM& vm, JSObject*)
3410{
3411 return CustomGetterSetter::create(vm, jsDOMWindow_webkitSpeechRecognitionConstructor, nullptr);
3412}
3413
3414static bool isEnabledJSDOMWindowInstance_webkitSpeechRecognition(JSGlobalObject* globalObject)
3415{
3416 UNUSED_PARAM(globalObject);
3417 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().speechRecognitionEnabled;
3418}
3419
3420static JSValue createJSDOMWindowInstance_SpeechRecognitionAlternative(VM& vm, JSObject*)
3421{
3422 return CustomGetterSetter::create(vm, jsDOMWindow_SpeechRecognitionAlternativeConstructor, nullptr);
3423}
3424
3425static bool isEnabledJSDOMWindowInstance_SpeechRecognitionAlternative(JSGlobalObject* globalObject)
3426{
3427 UNUSED_PARAM(globalObject);
3428 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().speechRecognitionEnabled;
3429}
3430
3431static JSValue createJSDOMWindowInstance_SpeechRecognitionErrorEvent(VM& vm, JSObject*)
3432{
3433 return CustomGetterSetter::create(vm, jsDOMWindow_SpeechRecognitionErrorEventConstructor, nullptr);
3434}
3435
3436static bool isEnabledJSDOMWindowInstance_SpeechRecognitionErrorEvent(JSGlobalObject* globalObject)
3437{
3438 UNUSED_PARAM(globalObject);
3439 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().speechRecognitionEnabled;
3440}
3441
3442static JSValue createJSDOMWindowInstance_SpeechRecognitionEvent(VM& vm, JSObject*)
3443{
3444 return CustomGetterSetter::create(vm, jsDOMWindow_SpeechRecognitionEventConstructor, nullptr);
3445}
3446
3447static bool isEnabledJSDOMWindowInstance_SpeechRecognitionEvent(JSGlobalObject* globalObject)
3448{
3449 UNUSED_PARAM(globalObject);
3450 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().speechRecognitionEnabled;
3451}
3452
3453static JSValue createJSDOMWindowInstance_SpeechRecognitionResult(VM& vm, JSObject*)
3454{
3455 return CustomGetterSetter::create(vm, jsDOMWindow_SpeechRecognitionResultConstructor, nullptr);
3456}
3457
3458static bool isEnabledJSDOMWindowInstance_SpeechRecognitionResult(JSGlobalObject* globalObject)
3459{
3460 UNUSED_PARAM(globalObject);
3461 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().speechRecognitionEnabled;
3462}
3463
3464static JSValue createJSDOMWindowInstance_SpeechRecognitionResultList(VM& vm, JSObject*)
3465{
3466 return CustomGetterSetter::create(vm, jsDOMWindow_SpeechRecognitionResultListConstructor, nullptr);
3467}
3468
3469static bool isEnabledJSDOMWindowInstance_SpeechRecognitionResultList(JSGlobalObject* globalObject)
3470{
3471 UNUSED_PARAM(globalObject);
3472 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().speechRecognitionEnabled;
3473}
3474
3475static JSValue createJSDOMWindowInstance_TransformStream(VM& vm, JSObject*)
3476{
3477 return CustomGetterSetter::create(vm, jsDOMWindow_TransformStreamConstructor, nullptr);
3478}
3479
3480static bool isEnabledJSDOMWindowInstance_TransformStream(JSGlobalObject* globalObject)
3481{
3482 UNUSED_PARAM(globalObject);
3483 return RuntimeEnabledFeatures::sharedFeatures().transformStreamAPIEnabled();
3484}
3485
3486static JSValue createJSDOMWindowInstance_TransformStreamDefaultController(VM& vm, JSObject*)
3487{
3488 return CustomGetterSetter::create(vm, jsDOMWindow_TransformStreamDefaultControllerConstructor, nullptr);
3489}
3490
3491static bool isEnabledJSDOMWindowInstance_TransformStreamDefaultController(JSGlobalObject* globalObject)
3492{
3493 UNUSED_PARAM(globalObject);
3494 return RuntimeEnabledFeatures::sharedFeatures().transformStreamAPIEnabled();
3495}
3496
3497static JSValue createJSDOMWindowInstance_WritableStream(VM& vm, JSObject*)
3498{
3499 return CustomGetterSetter::create(vm, jsDOMWindow_WritableStreamConstructor, nullptr);
3500}
3501
3502static bool isEnabledJSDOMWindowInstance_WritableStream(JSGlobalObject* globalObject)
3503{
3504 UNUSED_PARAM(globalObject);
3505 return RuntimeEnabledFeatures::sharedFeatures().writableStreamAPIEnabled();
3506}
3507
3508static JSValue createJSDOMWindowInstance_WritableStreamDefaultController(VM& vm, JSObject*)
3509{
3510 return CustomGetterSetter::create(vm, jsDOMWindow_WritableStreamDefaultControllerConstructor, nullptr);
3511}
3512
3513static bool isEnabledJSDOMWindowInstance_WritableStreamDefaultController(JSGlobalObject* globalObject)
3514{
3515 UNUSED_PARAM(globalObject);
3516 return RuntimeEnabledFeatures::sharedFeatures().writableStreamAPIEnabled();
3517}
3518
3519static JSValue createJSDOMWindowInstance_WritableStreamDefaultWriter(VM& vm, JSObject*)
3520{
3521 return CustomGetterSetter::create(vm, jsDOMWindow_WritableStreamDefaultWriterConstructor, nullptr);
3522}
3523
3524static bool isEnabledJSDOMWindowInstance_WritableStreamDefaultWriter(JSGlobalObject* globalObject)
3525{
3526 UNUSED_PARAM(globalObject);
3527 return RuntimeEnabledFeatures::sharedFeatures().writableStreamAPIEnabled();
3528}
3529
3530#if ENABLE(WEB_AUDIO)
3531static JSValue createJSDOMWindowInstance_AudioContext(VM& vm, JSObject*)
3532{
3533 return CustomGetterSetter::create(vm, jsDOMWindow_AudioContextConstructor, nullptr);
3534}
3535
3536static bool isEnabledJSDOMWindowInstance_AudioContext(JSGlobalObject* globalObject)
3537{
3538 UNUSED_PARAM(globalObject);
3539 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webAudioEnabled;
3540}
3541#endif
3542
3543#if ENABLE(WEB_AUDIO)
3544static JSValue createJSDOMWindowInstance_AudioParamMap(VM& vm, JSObject*)
3545{
3546 return CustomGetterSetter::create(vm, jsDOMWindow_AudioParamMapConstructor, nullptr);
3547}
3548
3549static bool isEnabledJSDOMWindowInstance_AudioParamMap(JSGlobalObject* globalObject)
3550{
3551 UNUSED_PARAM(globalObject);
3552 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webAudioEnabled;
3553}
3554#endif
3555
3556#if ENABLE(WEB_AUDIO)
3557static JSValue createJSDOMWindowInstance_AudioWorklet(VM& vm, JSObject*)
3558{
3559 return CustomGetterSetter::create(vm, jsDOMWindow_AudioWorkletConstructor, nullptr);
3560}
3561
3562static bool isEnabledJSDOMWindowInstance_AudioWorklet(JSGlobalObject* globalObject)
3563{
3564 UNUSED_PARAM(globalObject);
3565 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webAudioEnabled);
3566}
3567#endif
3568
3569#if ENABLE(WEB_AUDIO)
3570static JSValue createJSDOMWindowInstance_AudioWorkletNode(VM& vm, JSObject*)
3571{
3572 return CustomGetterSetter::create(vm, jsDOMWindow_AudioWorkletNodeConstructor, nullptr);
3573}
3574
3575static bool isEnabledJSDOMWindowInstance_AudioWorkletNode(JSGlobalObject* globalObject)
3576{
3577 UNUSED_PARAM(globalObject);
3578 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webAudioEnabled);
3579}
3580#endif
3581
3582#if ENABLE(WEB_AUDIO)
3583static JSValue createJSDOMWindowInstance_BaseAudioContext(VM& vm, JSObject*)
3584{
3585 return CustomGetterSetter::create(vm, jsDOMWindow_BaseAudioContextConstructor, nullptr);
3586}
3587
3588static bool isEnabledJSDOMWindowInstance_BaseAudioContext(JSGlobalObject* globalObject)
3589{
3590 UNUSED_PARAM(globalObject);
3591 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webAudioEnabled;
3592}
3593#endif
3594
3595#if ENABLE(WEB_AUDIO)
3596static JSValue createJSDOMWindowInstance_ConstantSourceNode(VM& vm, JSObject*)
3597{
3598 return CustomGetterSetter::create(vm, jsDOMWindow_ConstantSourceNodeConstructor, nullptr);
3599}
3600
3601static bool isEnabledJSDOMWindowInstance_ConstantSourceNode(JSGlobalObject* globalObject)
3602{
3603 UNUSED_PARAM(globalObject);
3604 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webAudioEnabled;
3605}
3606#endif
3607
3608#if ENABLE(WEB_AUDIO)
3609static JSValue createJSDOMWindowInstance_IIRFilterNode(VM& vm, JSObject*)
3610{
3611 return CustomGetterSetter::create(vm, jsDOMWindow_IIRFilterNodeConstructor, nullptr);
3612}
3613
3614static bool isEnabledJSDOMWindowInstance_IIRFilterNode(JSGlobalObject* globalObject)
3615{
3616 UNUSED_PARAM(globalObject);
3617 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webAudioEnabled;
3618}
3619#endif
3620
3621#if ENABLE(WEB_AUDIO)
3622static JSValue createJSDOMWindowInstance_OfflineAudioContext(VM& vm, JSObject*)
3623{
3624 return CustomGetterSetter::create(vm, jsDOMWindow_OfflineAudioContextConstructor, nullptr);
3625}
3626
3627static bool isEnabledJSDOMWindowInstance_OfflineAudioContext(JSGlobalObject* globalObject)
3628{
3629 UNUSED_PARAM(globalObject);
3630 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webAudioEnabled;
3631}
3632#endif
3633
3634#if ENABLE(WEB_AUDIO)
3635static JSValue createJSDOMWindowInstance_PannerNode(VM& vm, JSObject*)
3636{
3637 return CustomGetterSetter::create(vm, jsDOMWindow_PannerNodeConstructor, nullptr);
3638}
3639
3640static bool isEnabledJSDOMWindowInstance_PannerNode(JSGlobalObject* globalObject)
3641{
3642 UNUSED_PARAM(globalObject);
3643 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webAudioEnabled;
3644}
3645#endif
3646
3647#if ENABLE(WEB_AUDIO)
3648static JSValue createJSDOMWindowInstance_StereoPannerNode(VM& vm, JSObject*)
3649{
3650 return CustomGetterSetter::create(vm, jsDOMWindow_StereoPannerNodeConstructor, nullptr);
3651}
3652
3653static bool isEnabledJSDOMWindowInstance_StereoPannerNode(JSGlobalObject* globalObject)
3654{
3655 UNUSED_PARAM(globalObject);
3656 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webAudioEnabled;
3657}
3658#endif
3659
3660#if ENABLE(WEB_AUTHN)
3661static JSValue createJSDOMWindowInstance_AuthenticatorAssertionResponse(VM& vm, JSObject*)
3662{
3663 return CustomGetterSetter::create(vm, jsDOMWindow_AuthenticatorAssertionResponseConstructor, nullptr);
3664}
3665
3666static bool isEnabledJSDOMWindowInstance_AuthenticatorAssertionResponse(JSGlobalObject* globalObject)
3667{
3668 UNUSED_PARAM(globalObject);
3669 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webAuthenticationEnabled);
3670}
3671#endif
3672
3673#if ENABLE(WEB_AUTHN)
3674static JSValue createJSDOMWindowInstance_AuthenticatorAttestationResponse(VM& vm, JSObject*)
3675{
3676 return CustomGetterSetter::create(vm, jsDOMWindow_AuthenticatorAttestationResponseConstructor, nullptr);
3677}
3678
3679static bool isEnabledJSDOMWindowInstance_AuthenticatorAttestationResponse(JSGlobalObject* globalObject)
3680{
3681 UNUSED_PARAM(globalObject);
3682 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webAuthenticationEnabled);
3683}
3684#endif
3685
3686#if ENABLE(WEB_AUTHN)
3687static JSValue createJSDOMWindowInstance_AuthenticatorResponse(VM& vm, JSObject*)
3688{
3689 return CustomGetterSetter::create(vm, jsDOMWindow_AuthenticatorResponseConstructor, nullptr);
3690}
3691
3692static bool isEnabledJSDOMWindowInstance_AuthenticatorResponse(JSGlobalObject* globalObject)
3693{
3694 UNUSED_PARAM(globalObject);
3695 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webAuthenticationEnabled);
3696}
3697#endif
3698
3699#if ENABLE(WEB_AUTHN)
3700static JSValue createJSDOMWindowInstance_PublicKeyCredential(VM& vm, JSObject*)
3701{
3702 return CustomGetterSetter::create(vm, jsDOMWindow_PublicKeyCredentialConstructor, nullptr);
3703}
3704
3705static bool isEnabledJSDOMWindowInstance_PublicKeyCredential(JSGlobalObject* globalObject)
3706{
3707 UNUSED_PARAM(globalObject);
3708 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webAuthenticationEnabled);
3709}
3710#endif
3711
3712static JSValue createJSDOMWindowInstance_Database(VM& vm, JSObject*)
3713{
3714 return CustomGetterSetter::create(vm, jsDOMWindow_DatabaseConstructor, nullptr);
3715}
3716
3717static bool isEnabledJSDOMWindowInstance_Database(JSGlobalObject* globalObject)
3718{
3719 UNUSED_PARAM(globalObject);
3720 return RuntimeEnabledFeatures::sharedFeatures().webSQLEnabled();
3721}
3722
3723static JSValue createJSDOMWindowInstance_SQLError(VM& vm, JSObject*)
3724{
3725 return CustomGetterSetter::create(vm, jsDOMWindow_SQLErrorConstructor, nullptr);
3726}
3727
3728static bool isEnabledJSDOMWindowInstance_SQLError(JSGlobalObject* globalObject)
3729{
3730 UNUSED_PARAM(globalObject);
3731 return RuntimeEnabledFeatures::sharedFeatures().webSQLEnabled();
3732}
3733
3734static JSValue createJSDOMWindowInstance_SQLResultSet(VM& vm, JSObject*)
3735{
3736 return CustomGetterSetter::create(vm, jsDOMWindow_SQLResultSetConstructor, nullptr);
3737}
3738
3739static bool isEnabledJSDOMWindowInstance_SQLResultSet(JSGlobalObject* globalObject)
3740{
3741 UNUSED_PARAM(globalObject);
3742 return RuntimeEnabledFeatures::sharedFeatures().webSQLEnabled();
3743}
3744
3745static JSValue createJSDOMWindowInstance_SQLResultSetRowList(VM& vm, JSObject*)
3746{
3747 return CustomGetterSetter::create(vm, jsDOMWindow_SQLResultSetRowListConstructor, nullptr);
3748}
3749
3750static bool isEnabledJSDOMWindowInstance_SQLResultSetRowList(JSGlobalObject* globalObject)
3751{
3752 UNUSED_PARAM(globalObject);
3753 return RuntimeEnabledFeatures::sharedFeatures().webSQLEnabled();
3754}
3755
3756#if ENABLE(WEBGPU)
3757static JSValue createJSDOMWindowInstance_GPUBufferUsage(VM& vm, JSObject*)
3758{
3759 return CustomGetterSetter::create(vm, jsDOMWindow_GPUBufferUsageConstructor, nullptr);
3760}
3761
3762static bool isEnabledJSDOMWindowInstance_GPUBufferUsage(JSGlobalObject* globalObject)
3763{
3764 UNUSED_PARAM(globalObject);
3765 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webGPUEnabled;
3766}
3767#endif
3768
3769#if ENABLE(WEBGPU)
3770static JSValue createJSDOMWindowInstance_GPUCanvasContext(VM& vm, JSObject*)
3771{
3772 return CustomGetterSetter::create(vm, jsDOMWindow_GPUCanvasContextConstructor, nullptr);
3773}
3774
3775static bool isEnabledJSDOMWindowInstance_GPUCanvasContext(JSGlobalObject* globalObject)
3776{
3777 UNUSED_PARAM(globalObject);
3778 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webGPUEnabled;
3779}
3780#endif
3781
3782#if ENABLE(WEBGPU)
3783static JSValue createJSDOMWindowInstance_GPUColorWrite(VM& vm, JSObject*)
3784{
3785 return CustomGetterSetter::create(vm, jsDOMWindow_GPUColorWriteConstructor, nullptr);
3786}
3787
3788static bool isEnabledJSDOMWindowInstance_GPUColorWrite(JSGlobalObject* globalObject)
3789{
3790 UNUSED_PARAM(globalObject);
3791 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webGPUEnabled;
3792}
3793#endif
3794
3795#if ENABLE(WEBGPU)
3796static JSValue createJSDOMWindowInstance_GPUOutOfMemoryError(VM& vm, JSObject*)
3797{
3798 return CustomGetterSetter::create(vm, jsDOMWindow_GPUOutOfMemoryErrorConstructor, nullptr);
3799}
3800
3801static bool isEnabledJSDOMWindowInstance_GPUOutOfMemoryError(JSGlobalObject* globalObject)
3802{
3803 UNUSED_PARAM(globalObject);
3804 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webGPUEnabled;
3805}
3806#endif
3807
3808#if ENABLE(WEBGPU)
3809static JSValue createJSDOMWindowInstance_GPUShaderStage(VM& vm, JSObject*)
3810{
3811 return CustomGetterSetter::create(vm, jsDOMWindow_GPUShaderStageConstructor, nullptr);
3812}
3813
3814static bool isEnabledJSDOMWindowInstance_GPUShaderStage(JSGlobalObject* globalObject)
3815{
3816 UNUSED_PARAM(globalObject);
3817 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webGPUEnabled;
3818}
3819#endif
3820
3821#if ENABLE(WEBGPU)
3822static JSValue createJSDOMWindowInstance_GPUTextureUsage(VM& vm, JSObject*)
3823{
3824 return CustomGetterSetter::create(vm, jsDOMWindow_GPUTextureUsageConstructor, nullptr);
3825}
3826
3827static bool isEnabledJSDOMWindowInstance_GPUTextureUsage(JSGlobalObject* globalObject)
3828{
3829 UNUSED_PARAM(globalObject);
3830 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webGPUEnabled;
3831}
3832#endif
3833
3834#if ENABLE(WEBGPU)
3835static JSValue createJSDOMWindowInstance_GPUUncapturedErrorEvent(VM& vm, JSObject*)
3836{
3837 return CustomGetterSetter::create(vm, jsDOMWindow_GPUUncapturedErrorEventConstructor, nullptr);
3838}
3839
3840static bool isEnabledJSDOMWindowInstance_GPUUncapturedErrorEvent(JSGlobalObject* globalObject)
3841{
3842 UNUSED_PARAM(globalObject);
3843 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webGPUEnabled;
3844}
3845#endif
3846
3847#if ENABLE(WEBGPU)
3848static JSValue createJSDOMWindowInstance_GPUValidationError(VM& vm, JSObject*)
3849{
3850 return CustomGetterSetter::create(vm, jsDOMWindow_GPUValidationErrorConstructor, nullptr);
3851}
3852
3853static bool isEnabledJSDOMWindowInstance_GPUValidationError(JSGlobalObject* globalObject)
3854{
3855 UNUSED_PARAM(globalObject);
3856 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webGPUEnabled;
3857}
3858#endif
3859
3860#if ENABLE(WEBGPU)
3861static JSValue createJSDOMWindowInstance_GPU(VM& vm, JSObject*)
3862{
3863 return CustomGetterSetter::create(vm, jsDOMWindow_GPUConstructor, nullptr);
3864}
3865
3866static bool isEnabledJSDOMWindowInstance_GPU(JSGlobalObject* globalObject)
3867{
3868 UNUSED_PARAM(globalObject);
3869 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webGPUEnabled;
3870}
3871#endif
3872
3873#if ENABLE(WEBGPU)
3874static JSValue createJSDOMWindowInstance_GPUAdapter(VM& vm, JSObject*)
3875{
3876 return CustomGetterSetter::create(vm, jsDOMWindow_GPUAdapterConstructor, nullptr);
3877}
3878
3879static bool isEnabledJSDOMWindowInstance_GPUAdapter(JSGlobalObject* globalObject)
3880{
3881 UNUSED_PARAM(globalObject);
3882 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webGPUEnabled;
3883}
3884#endif
3885
3886#if ENABLE(WEBGPU)
3887static JSValue createJSDOMWindowInstance_GPUBindGroup(VM& vm, JSObject*)
3888{
3889 return CustomGetterSetter::create(vm, jsDOMWindow_GPUBindGroupConstructor, nullptr);
3890}
3891
3892static bool isEnabledJSDOMWindowInstance_GPUBindGroup(JSGlobalObject* globalObject)
3893{
3894 UNUSED_PARAM(globalObject);
3895 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webGPUEnabled;
3896}
3897#endif
3898
3899#if ENABLE(WEBGPU)
3900static JSValue createJSDOMWindowInstance_GPUBindGroupLayout(VM& vm, JSObject*)
3901{
3902 return CustomGetterSetter::create(vm, jsDOMWindow_GPUBindGroupLayoutConstructor, nullptr);
3903}
3904
3905static bool isEnabledJSDOMWindowInstance_GPUBindGroupLayout(JSGlobalObject* globalObject)
3906{
3907 UNUSED_PARAM(globalObject);
3908 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webGPUEnabled;
3909}
3910#endif
3911
3912#if ENABLE(WEBGPU)
3913static JSValue createJSDOMWindowInstance_GPUBuffer(VM& vm, JSObject*)
3914{
3915 return CustomGetterSetter::create(vm, jsDOMWindow_GPUBufferConstructor, nullptr);
3916}
3917
3918static bool isEnabledJSDOMWindowInstance_GPUBuffer(JSGlobalObject* globalObject)
3919{
3920 UNUSED_PARAM(globalObject);
3921 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webGPUEnabled;
3922}
3923#endif
3924
3925#if ENABLE(WEBGPU)
3926static JSValue createJSDOMWindowInstance_GPUCommandBuffer(VM& vm, JSObject*)
3927{
3928 return CustomGetterSetter::create(vm, jsDOMWindow_GPUCommandBufferConstructor, nullptr);
3929}
3930
3931static bool isEnabledJSDOMWindowInstance_GPUCommandBuffer(JSGlobalObject* globalObject)
3932{
3933 UNUSED_PARAM(globalObject);
3934 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webGPUEnabled;
3935}
3936#endif
3937
3938#if ENABLE(WEBGPU)
3939static JSValue createJSDOMWindowInstance_GPUCommandEncoder(VM& vm, JSObject*)
3940{
3941 return CustomGetterSetter::create(vm, jsDOMWindow_GPUCommandEncoderConstructor, nullptr);
3942}
3943
3944static bool isEnabledJSDOMWindowInstance_GPUCommandEncoder(JSGlobalObject* globalObject)
3945{
3946 UNUSED_PARAM(globalObject);
3947 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webGPUEnabled;
3948}
3949#endif
3950
3951#if ENABLE(WEBGPU)
3952static JSValue createJSDOMWindowInstance_GPUComputePassEncoder(VM& vm, JSObject*)
3953{
3954 return CustomGetterSetter::create(vm, jsDOMWindow_GPUComputePassEncoderConstructor, nullptr);
3955}
3956
3957static bool isEnabledJSDOMWindowInstance_GPUComputePassEncoder(JSGlobalObject* globalObject)
3958{
3959 UNUSED_PARAM(globalObject);
3960 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webGPUEnabled;
3961}
3962#endif
3963
3964#if ENABLE(WEBGPU)
3965static JSValue createJSDOMWindowInstance_GPUComputePipeline(VM& vm, JSObject*)
3966{
3967 return CustomGetterSetter::create(vm, jsDOMWindow_GPUComputePipelineConstructor, nullptr);
3968}
3969
3970static bool isEnabledJSDOMWindowInstance_GPUComputePipeline(JSGlobalObject* globalObject)
3971{
3972 UNUSED_PARAM(globalObject);
3973 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webGPUEnabled;
3974}
3975#endif
3976
3977#if ENABLE(WEBGPU)
3978static JSValue createJSDOMWindowInstance_GPUDevice(VM& vm, JSObject*)
3979{
3980 return CustomGetterSetter::create(vm, jsDOMWindow_GPUDeviceConstructor, nullptr);
3981}
3982
3983static bool isEnabledJSDOMWindowInstance_GPUDevice(JSGlobalObject* globalObject)
3984{
3985 UNUSED_PARAM(globalObject);
3986 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webGPUEnabled;
3987}
3988#endif
3989
3990#if ENABLE(WEBGPU)
3991static JSValue createJSDOMWindowInstance_GPUPipelineLayout(VM& vm, JSObject*)
3992{
3993 return CustomGetterSetter::create(vm, jsDOMWindow_GPUPipelineLayoutConstructor, nullptr);
3994}
3995
3996static bool isEnabledJSDOMWindowInstance_GPUPipelineLayout(JSGlobalObject* globalObject)
3997{
3998 UNUSED_PARAM(globalObject);
3999 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webGPUEnabled;
4000}
4001#endif
4002
4003#if ENABLE(WEBGPU)
4004static JSValue createJSDOMWindowInstance_GPUProgrammablePassEncoder(VM& vm, JSObject*)
4005{
4006 return CustomGetterSetter::create(vm, jsDOMWindow_GPUProgrammablePassEncoderConstructor, nullptr);
4007}
4008
4009static bool isEnabledJSDOMWindowInstance_GPUProgrammablePassEncoder(JSGlobalObject* globalObject)
4010{
4011 UNUSED_PARAM(globalObject);
4012 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webGPUEnabled;
4013}
4014#endif
4015
4016#if ENABLE(WEBGPU)
4017static JSValue createJSDOMWindowInstance_GPUQueue(VM& vm, JSObject*)
4018{
4019 return CustomGetterSetter::create(vm, jsDOMWindow_GPUQueueConstructor, nullptr);
4020}
4021
4022static bool isEnabledJSDOMWindowInstance_GPUQueue(JSGlobalObject* globalObject)
4023{
4024 UNUSED_PARAM(globalObject);
4025 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webGPUEnabled;
4026}
4027#endif
4028
4029#if ENABLE(WEBGPU)
4030static JSValue createJSDOMWindowInstance_GPURenderPassEncoder(VM& vm, JSObject*)
4031{
4032 return CustomGetterSetter::create(vm, jsDOMWindow_GPURenderPassEncoderConstructor, nullptr);
4033}
4034
4035static bool isEnabledJSDOMWindowInstance_GPURenderPassEncoder(JSGlobalObject* globalObject)
4036{
4037 UNUSED_PARAM(globalObject);
4038 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webGPUEnabled;
4039}
4040#endif
4041
4042#if ENABLE(WEBGPU)
4043static JSValue createJSDOMWindowInstance_GPURenderPipeline(VM& vm, JSObject*)
4044{
4045 return CustomGetterSetter::create(vm, jsDOMWindow_GPURenderPipelineConstructor, nullptr);
4046}
4047
4048static bool isEnabledJSDOMWindowInstance_GPURenderPipeline(JSGlobalObject* globalObject)
4049{
4050 UNUSED_PARAM(globalObject);
4051 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webGPUEnabled;
4052}
4053#endif
4054
4055#if ENABLE(WEBGPU)
4056static JSValue createJSDOMWindowInstance_GPUSampler(VM& vm, JSObject*)
4057{
4058 return CustomGetterSetter::create(vm, jsDOMWindow_GPUSamplerConstructor, nullptr);
4059}
4060
4061static bool isEnabledJSDOMWindowInstance_GPUSampler(JSGlobalObject* globalObject)
4062{
4063 UNUSED_PARAM(globalObject);
4064 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webGPUEnabled;
4065}
4066#endif
4067
4068#if ENABLE(WEBGPU)
4069static JSValue createJSDOMWindowInstance_GPUShaderModule(VM& vm, JSObject*)
4070{
4071 return CustomGetterSetter::create(vm, jsDOMWindow_GPUShaderModuleConstructor, nullptr);
4072}
4073
4074static bool isEnabledJSDOMWindowInstance_GPUShaderModule(JSGlobalObject* globalObject)
4075{
4076 UNUSED_PARAM(globalObject);
4077 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webGPUEnabled;
4078}
4079#endif
4080
4081#if ENABLE(WEBGPU)
4082static JSValue createJSDOMWindowInstance_GPUSwapChain(VM& vm, JSObject*)
4083{
4084 return CustomGetterSetter::create(vm, jsDOMWindow_GPUSwapChainConstructor, nullptr);
4085}
4086
4087static bool isEnabledJSDOMWindowInstance_GPUSwapChain(JSGlobalObject* globalObject)
4088{
4089 UNUSED_PARAM(globalObject);
4090 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webGPUEnabled;
4091}
4092#endif
4093
4094#if ENABLE(WEBGPU)
4095static JSValue createJSDOMWindowInstance_GPUTexture(VM& vm, JSObject*)
4096{
4097 return CustomGetterSetter::create(vm, jsDOMWindow_GPUTextureConstructor, nullptr);
4098}
4099
4100static bool isEnabledJSDOMWindowInstance_GPUTexture(JSGlobalObject* globalObject)
4101{
4102 UNUSED_PARAM(globalObject);
4103 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webGPUEnabled;
4104}
4105#endif
4106
4107#if ENABLE(WEBGPU)
4108static JSValue createJSDOMWindowInstance_GPUTextureView(VM& vm, JSObject*)
4109{
4110 return CustomGetterSetter::create(vm, jsDOMWindow_GPUTextureViewConstructor, nullptr);
4111}
4112
4113static bool isEnabledJSDOMWindowInstance_GPUTextureView(JSGlobalObject* globalObject)
4114{
4115 UNUSED_PARAM(globalObject);
4116 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webGPUEnabled;
4117}
4118#endif
4119
4120static JSValue createJSDOMWindowInstance_WebSocket(VM& vm, JSObject*)
4121{
4122 return CustomGetterSetter::create(vm, jsDOMWindow_WebSocketConstructor, nullptr);
4123}
4124
4125static bool isEnabledJSDOMWindowInstance_WebSocket(JSGlobalObject* globalObject)
4126{
4127 UNUSED_PARAM(globalObject);
4128 return RuntimeEnabledFeatures::sharedFeatures().webSocketEnabled();
4129}
4130
4131#if ENABLE(WEBXR)
4132static JSValue createJSDOMWindowInstance_XRBoundedReferenceSpace(VM& vm, JSObject*)
4133{
4134 return CustomGetterSetter::create(vm, jsDOMWindow_XRBoundedReferenceSpaceConstructor, nullptr);
4135}
4136
4137static bool isEnabledJSDOMWindowInstance_XRBoundedReferenceSpace(JSGlobalObject* globalObject)
4138{
4139 UNUSED_PARAM(globalObject);
4140 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webXREnabled);
4141}
4142#endif
4143
4144#if ENABLE(WEBXR)
4145static JSValue createJSDOMWindowInstance_XRFrame(VM& vm, JSObject*)
4146{
4147 return CustomGetterSetter::create(vm, jsDOMWindow_XRFrameConstructor, nullptr);
4148}
4149
4150static bool isEnabledJSDOMWindowInstance_XRFrame(JSGlobalObject* globalObject)
4151{
4152 UNUSED_PARAM(globalObject);
4153 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webXREnabled);
4154}
4155#endif
4156
4157#if ENABLE(WEBXR)
4158static JSValue createJSDOMWindowInstance_XRInputSource(VM& vm, JSObject*)
4159{
4160 return CustomGetterSetter::create(vm, jsDOMWindow_XRInputSourceConstructor, nullptr);
4161}
4162
4163static bool isEnabledJSDOMWindowInstance_XRInputSource(JSGlobalObject* globalObject)
4164{
4165 UNUSED_PARAM(globalObject);
4166 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webXREnabled);
4167}
4168#endif
4169
4170#if ENABLE(WEBXR)
4171static JSValue createJSDOMWindowInstance_XRInputSourceArray(VM& vm, JSObject*)
4172{
4173 return CustomGetterSetter::create(vm, jsDOMWindow_XRInputSourceArrayConstructor, nullptr);
4174}
4175
4176static bool isEnabledJSDOMWindowInstance_XRInputSourceArray(JSGlobalObject* globalObject)
4177{
4178 UNUSED_PARAM(globalObject);
4179 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webXREnabled);
4180}
4181#endif
4182
4183#if ENABLE(WEBXR)
4184static JSValue createJSDOMWindowInstance_XRLayer(VM& vm, JSObject*)
4185{
4186 return CustomGetterSetter::create(vm, jsDOMWindow_XRLayerConstructor, nullptr);
4187}
4188
4189static bool isEnabledJSDOMWindowInstance_XRLayer(JSGlobalObject* globalObject)
4190{
4191 UNUSED_PARAM(globalObject);
4192 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webXREnabled);
4193}
4194#endif
4195
4196#if ENABLE(WEBXR)
4197static JSValue createJSDOMWindowInstance_XRPose(VM& vm, JSObject*)
4198{
4199 return CustomGetterSetter::create(vm, jsDOMWindow_XRPoseConstructor, nullptr);
4200}
4201
4202static bool isEnabledJSDOMWindowInstance_XRPose(JSGlobalObject* globalObject)
4203{
4204 UNUSED_PARAM(globalObject);
4205 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webXREnabled);
4206}
4207#endif
4208
4209#if ENABLE(WEBXR)
4210static JSValue createJSDOMWindowInstance_XRReferenceSpace(VM& vm, JSObject*)
4211{
4212 return CustomGetterSetter::create(vm, jsDOMWindow_XRReferenceSpaceConstructor, nullptr);
4213}
4214
4215static bool isEnabledJSDOMWindowInstance_XRReferenceSpace(JSGlobalObject* globalObject)
4216{
4217 UNUSED_PARAM(globalObject);
4218 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webXREnabled);
4219}
4220#endif
4221
4222#if ENABLE(WEBXR)
4223static JSValue createJSDOMWindowInstance_XRRenderState(VM& vm, JSObject*)
4224{
4225 return CustomGetterSetter::create(vm, jsDOMWindow_XRRenderStateConstructor, nullptr);
4226}
4227
4228static bool isEnabledJSDOMWindowInstance_XRRenderState(JSGlobalObject* globalObject)
4229{
4230 UNUSED_PARAM(globalObject);
4231 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webXREnabled);
4232}
4233#endif
4234
4235#if ENABLE(WEBXR)
4236static JSValue createJSDOMWindowInstance_XRRigidTransform(VM& vm, JSObject*)
4237{
4238 return CustomGetterSetter::create(vm, jsDOMWindow_XRRigidTransformConstructor, nullptr);
4239}
4240
4241static bool isEnabledJSDOMWindowInstance_XRRigidTransform(JSGlobalObject* globalObject)
4242{
4243 UNUSED_PARAM(globalObject);
4244 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webXREnabled);
4245}
4246#endif
4247
4248#if ENABLE(WEBXR)
4249static JSValue createJSDOMWindowInstance_XRSession(VM& vm, JSObject*)
4250{
4251 return CustomGetterSetter::create(vm, jsDOMWindow_XRSessionConstructor, nullptr);
4252}
4253
4254static bool isEnabledJSDOMWindowInstance_XRSession(JSGlobalObject* globalObject)
4255{
4256 UNUSED_PARAM(globalObject);
4257 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webXREnabled);
4258}
4259#endif
4260
4261#if ENABLE(WEBXR)
4262static JSValue createJSDOMWindowInstance_XRSpace(VM& vm, JSObject*)
4263{
4264 return CustomGetterSetter::create(vm, jsDOMWindow_XRSpaceConstructor, nullptr);
4265}
4266
4267static bool isEnabledJSDOMWindowInstance_XRSpace(JSGlobalObject* globalObject)
4268{
4269 UNUSED_PARAM(globalObject);
4270 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webXREnabled);
4271}
4272#endif
4273
4274#if ENABLE(WEBXR)
4275static JSValue createJSDOMWindowInstance_XRSystem(VM& vm, JSObject*)
4276{
4277 return CustomGetterSetter::create(vm, jsDOMWindow_XRSystemConstructor, nullptr);
4278}
4279
4280static bool isEnabledJSDOMWindowInstance_XRSystem(JSGlobalObject* globalObject)
4281{
4282 UNUSED_PARAM(globalObject);
4283 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webXREnabled);
4284}
4285#endif
4286
4287#if ENABLE(WEBXR)
4288static JSValue createJSDOMWindowInstance_XRView(VM& vm, JSObject*)
4289{
4290 return CustomGetterSetter::create(vm, jsDOMWindow_XRViewConstructor, nullptr);
4291}
4292
4293static bool isEnabledJSDOMWindowInstance_XRView(JSGlobalObject* globalObject)
4294{
4295 UNUSED_PARAM(globalObject);
4296 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webXREnabled);
4297}
4298#endif
4299
4300#if ENABLE(WEBXR)
4301static JSValue createJSDOMWindowInstance_XRViewerPose(VM& vm, JSObject*)
4302{
4303 return CustomGetterSetter::create(vm, jsDOMWindow_XRViewerPoseConstructor, nullptr);
4304}
4305
4306static bool isEnabledJSDOMWindowInstance_XRViewerPose(JSGlobalObject* globalObject)
4307{
4308 UNUSED_PARAM(globalObject);
4309 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webXREnabled);
4310}
4311#endif
4312
4313#if ENABLE(WEBXR)
4314static JSValue createJSDOMWindowInstance_XRViewport(VM& vm, JSObject*)
4315{
4316 return CustomGetterSetter::create(vm, jsDOMWindow_XRViewportConstructor, nullptr);
4317}
4318
4319static bool isEnabledJSDOMWindowInstance_XRViewport(JSGlobalObject* globalObject)
4320{
4321 UNUSED_PARAM(globalObject);
4322 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webXREnabled);
4323}
4324#endif
4325
4326#if ENABLE(WEBXR)
4327static JSValue createJSDOMWindowInstance_XRWebGLLayer(VM& vm, JSObject*)
4328{
4329 return CustomGetterSetter::create(vm, jsDOMWindow_XRWebGLLayerConstructor, nullptr);
4330}
4331
4332static bool isEnabledJSDOMWindowInstance_XRWebGLLayer(JSGlobalObject* globalObject)
4333{
4334 UNUSED_PARAM(globalObject);
4335 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webXREnabled);
4336}
4337#endif
4338
4339#if ENABLE(WEBXR)
4340static JSValue createJSDOMWindowInstance_XRInputSourceEvent(VM& vm, JSObject*)
4341{
4342 return CustomGetterSetter::create(vm, jsDOMWindow_XRInputSourceEventConstructor, nullptr);
4343}
4344
4345static bool isEnabledJSDOMWindowInstance_XRInputSourceEvent(JSGlobalObject* globalObject)
4346{
4347 UNUSED_PARAM(globalObject);
4348 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webXREnabled);
4349}
4350#endif
4351
4352#if ENABLE(WEBXR)
4353static JSValue createJSDOMWindowInstance_XRInputSourcesChangeEvent(VM& vm, JSObject*)
4354{
4355 return CustomGetterSetter::create(vm, jsDOMWindow_XRInputSourcesChangeEventConstructor, nullptr);
4356}
4357
4358static bool isEnabledJSDOMWindowInstance_XRInputSourcesChangeEvent(JSGlobalObject* globalObject)
4359{
4360 UNUSED_PARAM(globalObject);
4361 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webXREnabled);
4362}
4363#endif
4364
4365#if ENABLE(WEBXR)
4366static JSValue createJSDOMWindowInstance_XRReferenceSpaceEvent(VM& vm, JSObject*)
4367{
4368 return CustomGetterSetter::create(vm, jsDOMWindow_XRReferenceSpaceEventConstructor, nullptr);
4369}
4370
4371static bool isEnabledJSDOMWindowInstance_XRReferenceSpaceEvent(JSGlobalObject* globalObject)
4372{
4373 UNUSED_PARAM(globalObject);
4374 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webXREnabled);
4375}
4376#endif
4377
4378#if ENABLE(WEBXR)
4379static JSValue createJSDOMWindowInstance_XRSessionEvent(VM& vm, JSObject*)
4380{
4381 return CustomGetterSetter::create(vm, jsDOMWindow_XRSessionEventConstructor, nullptr);
4382}
4383
4384static bool isEnabledJSDOMWindowInstance_XRSessionEvent(JSGlobalObject* globalObject)
4385{
4386 UNUSED_PARAM(globalObject);
4387 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webXREnabled);
4388}
4389#endif
4390
4391static JSValue createJSDOMWindowInstance_CSSCounterStyleRule(VM& vm, JSObject*)
4392{
4393 return CustomGetterSetter::create(vm, jsDOMWindow_CSSCounterStyleRuleConstructor, nullptr);
4394}
4395
4396static bool isEnabledJSDOMWindowInstance_CSSCounterStyleRule(JSGlobalObject* globalObject)
4397{
4398 UNUSED_PARAM(globalObject);
4399 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().cssCounterStyleAtRulesEnabled;
4400}
4401
4402#if ENABLE(CSS_TYPED_OM)
4403static JSValue createJSDOMWindowInstance_StylePropertyMap(VM& vm, JSObject*)
4404{
4405 return CustomGetterSetter::create(vm, jsDOMWindow_StylePropertyMapConstructor, nullptr);
4406}
4407
4408static bool isEnabledJSDOMWindowInstance_StylePropertyMap(JSGlobalObject* globalObject)
4409{
4410 UNUSED_PARAM(globalObject);
4411 return RuntimeEnabledFeatures::sharedFeatures().cssTypedOMEnabled();
4412}
4413#endif
4414
4415#if ENABLE(CSS_TYPED_OM)
4416static JSValue createJSDOMWindowInstance_StylePropertyMapReadOnly(VM& vm, JSObject*)
4417{
4418 return CustomGetterSetter::create(vm, jsDOMWindow_StylePropertyMapReadOnlyConstructor, nullptr);
4419}
4420
4421static bool isEnabledJSDOMWindowInstance_StylePropertyMapReadOnly(JSGlobalObject* globalObject)
4422{
4423 UNUSED_PARAM(globalObject);
4424 return RuntimeEnabledFeatures::sharedFeatures().cssTypedOMEnabled();
4425}
4426#endif
4427
4428#if ENABLE(CSS_TYPED_OM)
4429static JSValue createJSDOMWindowInstance_CSSImageValue(VM& vm, JSObject*)
4430{
4431 return CustomGetterSetter::create(vm, jsDOMWindow_CSSImageValueConstructor, nullptr);
4432}
4433
4434static bool isEnabledJSDOMWindowInstance_CSSImageValue(JSGlobalObject* globalObject)
4435{
4436 UNUSED_PARAM(globalObject);
4437 return RuntimeEnabledFeatures::sharedFeatures().cssTypedOMEnabled();
4438}
4439#endif
4440
4441#if ENABLE(CSS_TYPED_OM)
4442static JSValue createJSDOMWindowInstance_CSSNumericValue(VM& vm, JSObject*)
4443{
4444 return CustomGetterSetter::create(vm, jsDOMWindow_CSSNumericValueConstructor, nullptr);
4445}
4446
4447static bool isEnabledJSDOMWindowInstance_CSSNumericValue(JSGlobalObject* globalObject)
4448{
4449 UNUSED_PARAM(globalObject);
4450 return RuntimeEnabledFeatures::sharedFeatures().cssTypedOMEnabled();
4451}
4452#endif
4453
4454#if ENABLE(CSS_TYPED_OM)
4455static JSValue createJSDOMWindowInstance_CSSStyleValue(VM& vm, JSObject*)
4456{
4457 return CustomGetterSetter::create(vm, jsDOMWindow_CSSStyleValueConstructor, nullptr);
4458}
4459
4460static bool isEnabledJSDOMWindowInstance_CSSStyleValue(JSGlobalObject* globalObject)
4461{
4462 UNUSED_PARAM(globalObject);
4463 return RuntimeEnabledFeatures::sharedFeatures().cssTypedOMEnabled();
4464}
4465#endif
4466
4467#if ENABLE(CSS_TYPED_OM)
4468static JSValue createJSDOMWindowInstance_CSSUnitValue(VM& vm, JSObject*)
4469{
4470 return CustomGetterSetter::create(vm, jsDOMWindow_CSSUnitValueConstructor, nullptr);
4471}
4472
4473static bool isEnabledJSDOMWindowInstance_CSSUnitValue(JSGlobalObject* globalObject)
4474{
4475 UNUSED_PARAM(globalObject);
4476 return RuntimeEnabledFeatures::sharedFeatures().cssTypedOMEnabled();
4477}
4478#endif
4479
4480#if ENABLE(CSS_TYPED_OM)
4481static JSValue createJSDOMWindowInstance_CSSUnparsedValue(VM& vm, JSObject*)
4482{
4483 return CustomGetterSetter::create(vm, jsDOMWindow_CSSUnparsedValueConstructor, nullptr);
4484}
4485
4486static bool isEnabledJSDOMWindowInstance_CSSUnparsedValue(JSGlobalObject* globalObject)
4487{
4488 UNUSED_PARAM(globalObject);
4489 return RuntimeEnabledFeatures::sharedFeatures().cssTypedOMEnabled();
4490}
4491#endif
4492
4493static JSValue createJSDOMWindowInstance_BeforeLoadEvent(VM& vm, JSObject*)
4494{
4495 return CustomGetterSetter::create(vm, jsDOMWindow_BeforeLoadEventConstructor, nullptr);
4496}
4497
4498static bool isEnabledJSDOMWindowInstance_BeforeLoadEvent(JSGlobalObject* globalObject)
4499{
4500 UNUSED_PARAM(globalObject);
4501 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().legacyBeforeLoadEventEnabled;
4502}
4503
4504static JSValue createJSDOMWindowInstance_DataTransferItem(VM& vm, JSObject*)
4505{
4506 return CustomGetterSetter::create(vm, jsDOMWindow_DataTransferItemConstructor, nullptr);
4507}
4508
4509static bool isEnabledJSDOMWindowInstance_DataTransferItem(JSGlobalObject* globalObject)
4510{
4511 UNUSED_PARAM(globalObject);
4512 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().dataTransferItemsEnabled;
4513}
4514
4515static JSValue createJSDOMWindowInstance_DataTransferItemList(VM& vm, JSObject*)
4516{
4517 return CustomGetterSetter::create(vm, jsDOMWindow_DataTransferItemListConstructor, nullptr);
4518}
4519
4520static bool isEnabledJSDOMWindowInstance_DataTransferItemList(JSGlobalObject* globalObject)
4521{
4522 UNUSED_PARAM(globalObject);
4523 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().dataTransferItemsEnabled;
4524}
4525
4526static JSValue createJSDOMWindowInstance_IdleDeadline(VM& vm, JSObject*)
4527{
4528 return CustomGetterSetter::create(vm, jsDOMWindow_IdleDeadlineConstructor, nullptr);
4529}
4530
4531static bool isEnabledJSDOMWindowInstance_IdleDeadline(JSGlobalObject* globalObject)
4532{
4533 UNUSED_PARAM(globalObject);
4534 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().requestIdleCallbackEnabled;
4535}
4536
4537static JSValue createJSDOMWindowInstance_InputEvent(VM& vm, JSObject*)
4538{
4539 return CustomGetterSetter::create(vm, jsDOMWindow_InputEventConstructor, nullptr);
4540}
4541
4542static bool isEnabledJSDOMWindowInstance_InputEvent(JSGlobalObject* globalObject)
4543{
4544 UNUSED_PARAM(globalObject);
4545 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().inputEventsEnabled;
4546}
4547
4548static JSValue createJSDOMWindowInstance_PointerEvent(VM& vm, JSObject*)
4549{
4550 return CustomGetterSetter::create(vm, jsDOMWindow_PointerEventConstructor, nullptr);
4551}
4552
4553static bool isEnabledJSDOMWindowInstance_PointerEvent(JSGlobalObject* globalObject)
4554{
4555 UNUSED_PARAM(globalObject);
4556 return !downcast<Document>(jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext())->quirks().shouldDisablePointerEventsQuirk();
4557}
4558
4559static JSValue createJSDOMWindowInstance_TextDecoderStream(VM& vm, JSObject*)
4560{
4561 return CustomGetterSetter::create(vm, jsDOMWindow_TextDecoderStreamConstructor, nullptr);
4562}
4563
4564static bool isEnabledJSDOMWindowInstance_TextDecoderStream(JSGlobalObject* globalObject)
4565{
4566 UNUSED_PARAM(globalObject);
4567 return RuntimeEnabledFeatures::sharedFeatures().transformStreamAPIEnabled();
4568}
4569
4570static JSValue createJSDOMWindowInstance_TextEncoderStream(VM& vm, JSObject*)
4571{
4572 return CustomGetterSetter::create(vm, jsDOMWindow_TextEncoderStreamConstructor, nullptr);
4573}
4574
4575static bool isEnabledJSDOMWindowInstance_TextEncoderStream(JSGlobalObject* globalObject)
4576{
4577 UNUSED_PARAM(globalObject);
4578 return RuntimeEnabledFeatures::sharedFeatures().transformStreamAPIEnabled();
4579}
4580
4581#if ENABLE(ATTACHMENT_ELEMENT)
4582static JSValue createJSDOMWindowInstance_HTMLAttachmentElement(VM& vm, JSObject*)
4583{
4584 return CustomGetterSetter::create(vm, jsDOMWindow_HTMLAttachmentElementConstructor, nullptr);
4585}
4586
4587static bool isEnabledJSDOMWindowInstance_HTMLAttachmentElement(JSGlobalObject* globalObject)
4588{
4589 UNUSED_PARAM(globalObject);
4590 return RuntimeEnabledFeatures::sharedFeatures().attachmentElementEnabled();
4591}
4592#endif
4593
4594#if ENABLE(DATALIST_ELEMENT)
4595static JSValue createJSDOMWindowInstance_HTMLDataListElement(VM& vm, JSObject*)
4596{
4597 return CustomGetterSetter::create(vm, jsDOMWindow_HTMLDataListElementConstructor, nullptr);
4598}
4599
4600static bool isEnabledJSDOMWindowInstance_HTMLDataListElement(JSGlobalObject* globalObject)
4601{
4602 UNUSED_PARAM(globalObject);
4603 return RuntimeEnabledFeatures::sharedFeatures().dataListElementEnabled();
4604}
4605#endif
4606
4607static JSValue createJSDOMWindowInstance_HTMLDialogElement(VM& vm, JSObject*)
4608{
4609 return CustomGetterSetter::create(vm, jsDOMWindow_HTMLDialogElementConstructor, nullptr);
4610}
4611
4612static bool isEnabledJSDOMWindowInstance_HTMLDialogElement(JSGlobalObject* globalObject)
4613{
4614 UNUSED_PARAM(globalObject);
4615 return RuntimeEnabledFeatures::sharedFeatures().dialogElementEnabled();
4616}
4617
4618static JSValue createJSDOMWindowInstance_HTMLKeygenElement(VM& vm, JSObject*)
4619{
4620 return CustomGetterSetter::create(vm, jsDOMWindow_HTMLKeygenElementConstructor, nullptr);
4621}
4622
4623static bool isEnabledJSDOMWindowInstance_HTMLKeygenElement(JSGlobalObject* globalObject)
4624{
4625 UNUSED_PARAM(globalObject);
4626 return RuntimeEnabledFeatures::sharedFeatures().keygenElementEnabled();
4627}
4628
4629static JSValue createJSDOMWindowInstance_HTMLMenuItemElement(VM& vm, JSObject*)
4630{
4631 return CustomGetterSetter::create(vm, jsDOMWindow_HTMLMenuItemElementConstructor, nullptr);
4632}
4633
4634static bool isEnabledJSDOMWindowInstance_HTMLMenuItemElement(JSGlobalObject* globalObject)
4635{
4636 UNUSED_PARAM(globalObject);
4637 return RuntimeEnabledFeatures::sharedFeatures().menuItemElementEnabled();
4638}
4639
4640static JSValue createJSDOMWindowInstance_ImageBitmap(VM& vm, JSObject*)
4641{
4642 return CustomGetterSetter::create(vm, jsDOMWindow_ImageBitmapConstructor, nullptr);
4643}
4644
4645static bool isEnabledJSDOMWindowInstance_ImageBitmap(JSGlobalObject* globalObject)
4646{
4647 UNUSED_PARAM(globalObject);
4648 return RuntimeEnabledFeatures::sharedFeatures().imageBitmapEnabled();
4649}
4650
4651#if ENABLE(ENCRYPTED_MEDIA)
4652static JSValue createJSDOMWindowInstance_MediaEncryptedEvent(VM& vm, JSObject*)
4653{
4654 return CustomGetterSetter::create(vm, jsDOMWindow_MediaEncryptedEventConstructor, nullptr);
4655}
4656
4657static bool isEnabledJSDOMWindowInstance_MediaEncryptedEvent(JSGlobalObject* globalObject)
4658{
4659 UNUSED_PARAM(globalObject);
4660 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().encryptedMediaAPIEnabled && !downcast<Document>(jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext())->quirks().hasBrokenEncryptedMediaAPISupportQuirk());
4661}
4662#endif
4663
4664#if ENABLE(OFFSCREEN_CANVAS)
4665static JSValue createJSDOMWindowInstance_OffscreenCanvas(VM& vm, JSObject*)
4666{
4667 return CustomGetterSetter::create(vm, jsDOMWindow_OffscreenCanvasConstructor, nullptr);
4668}
4669
4670static bool isEnabledJSDOMWindowInstance_OffscreenCanvas(JSGlobalObject* globalObject)
4671{
4672 UNUSED_PARAM(globalObject);
4673 return (RuntimeEnabledFeatures::sharedFeatures().offscreenCanvasEnabled() && OffscreenCanvas::enabledForContext(*jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()));
4674}
4675#endif
4676
4677#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
4678static JSValue createJSDOMWindowInstance_WebKitMediaKeyError(VM& vm, JSObject*)
4679{
4680 return CustomGetterSetter::create(vm, jsDOMWindow_WebKitMediaKeyErrorConstructor, nullptr);
4681}
4682
4683static bool isEnabledJSDOMWindowInstance_WebKitMediaKeyError(JSGlobalObject* globalObject)
4684{
4685 UNUSED_PARAM(globalObject);
4686 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().legacyEncryptedMediaAPIEnabled;
4687}
4688#endif
4689
4690static JSValue createJSDOMWindowInstance_ImageBitmapRenderingContext(VM& vm, JSObject*)
4691{
4692 return CustomGetterSetter::create(vm, jsDOMWindow_ImageBitmapRenderingContextConstructor, nullptr);
4693}
4694
4695static bool isEnabledJSDOMWindowInstance_ImageBitmapRenderingContext(JSGlobalObject* globalObject)
4696{
4697 UNUSED_PARAM(globalObject);
4698 return RuntimeEnabledFeatures::sharedFeatures().imageBitmapEnabled();
4699}
4700
4701#if ENABLE(OFFSCREEN_CANVAS)
4702static JSValue createJSDOMWindowInstance_OffscreenCanvasRenderingContext2D(VM& vm, JSObject*)
4703{
4704 return CustomGetterSetter::create(vm, jsDOMWindow_OffscreenCanvasRenderingContext2DConstructor, nullptr);
4705}
4706
4707static bool isEnabledJSDOMWindowInstance_OffscreenCanvasRenderingContext2D(JSGlobalObject* globalObject)
4708{
4709 UNUSED_PARAM(globalObject);
4710 return (RuntimeEnabledFeatures::sharedFeatures().offscreenCanvasEnabled() && OffscreenCanvasRenderingContext2D::enabledForContext(*jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()));
4711}
4712#endif
4713
4714#if ENABLE(WEBGL2)
4715static JSValue createJSDOMWindowInstance_WebGL2RenderingContext(VM& vm, JSObject*)
4716{
4717 return CustomGetterSetter::create(vm, jsDOMWindow_WebGL2RenderingContextConstructor, nullptr);
4718}
4719
4720static bool isEnabledJSDOMWindowInstance_WebGL2RenderingContext(JSGlobalObject* globalObject)
4721{
4722 UNUSED_PARAM(globalObject);
4723 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webGL2Enabled;
4724}
4725#endif
4726
4727#if ENABLE(WEBGL2)
4728static JSValue createJSDOMWindowInstance_WebGLTransformFeedback(VM& vm, JSObject*)
4729{
4730 return CustomGetterSetter::create(vm, jsDOMWindow_WebGLTransformFeedbackConstructor, nullptr);
4731}
4732
4733static bool isEnabledJSDOMWindowInstance_WebGLTransformFeedback(JSGlobalObject* globalObject)
4734{
4735 UNUSED_PARAM(globalObject);
4736 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webGL2Enabled;
4737}
4738#endif
4739
4740#if ENABLE(WEBGL2)
4741static JSValue createJSDOMWindowInstance_WebGLVertexArrayObject(VM& vm, JSObject*)
4742{
4743 return CustomGetterSetter::create(vm, jsDOMWindow_WebGLVertexArrayObjectConstructor, nullptr);
4744}
4745
4746static bool isEnabledJSDOMWindowInstance_WebGLVertexArrayObject(JSGlobalObject* globalObject)
4747{
4748 UNUSED_PARAM(globalObject);
4749 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().webGL2Enabled;
4750}
4751#endif
4752
4753#if ENABLE(INTERSECTION_OBSERVER)
4754static JSValue createJSDOMWindowInstance_IntersectionObserver(VM& vm, JSObject*)
4755{
4756 return CustomGetterSetter::create(vm, jsDOMWindow_IntersectionObserverConstructor, nullptr);
4757}
4758
4759static bool isEnabledJSDOMWindowInstance_IntersectionObserver(JSGlobalObject* globalObject)
4760{
4761 UNUSED_PARAM(globalObject);
4762 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().intersectionObserverEnabled;
4763}
4764#endif
4765
4766#if ENABLE(INTERSECTION_OBSERVER)
4767static JSValue createJSDOMWindowInstance_IntersectionObserverEntry(VM& vm, JSObject*)
4768{
4769 return CustomGetterSetter::create(vm, jsDOMWindow_IntersectionObserverEntryConstructor, nullptr);
4770}
4771
4772static bool isEnabledJSDOMWindowInstance_IntersectionObserverEntry(JSGlobalObject* globalObject)
4773{
4774 UNUSED_PARAM(globalObject);
4775 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().intersectionObserverEnabled;
4776}
4777#endif
4778
4779static JSValue createJSDOMWindowInstance_PerformanceNavigationTiming(VM& vm, JSObject*)
4780{
4781 return CustomGetterSetter::create(vm, jsDOMWindow_PerformanceNavigationTimingConstructor, nullptr);
4782}
4783
4784static bool isEnabledJSDOMWindowInstance_PerformanceNavigationTiming(JSGlobalObject* globalObject)
4785{
4786 UNUSED_PARAM(globalObject);
4787 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().performanceNavigationTimingAPIEnabled;
4788}
4789
4790static JSValue createJSDOMWindowInstance_PerformancePaintTiming(VM& vm, JSObject*)
4791{
4792 return CustomGetterSetter::create(vm, jsDOMWindow_PerformancePaintTimingConstructor, nullptr);
4793}
4794
4795static bool isEnabledJSDOMWindowInstance_PerformancePaintTiming(JSGlobalObject* globalObject)
4796{
4797 UNUSED_PARAM(globalObject);
4798 return RuntimeEnabledFeatures::sharedFeatures().paintTimingEnabled();
4799}
4800
4801static JSValue createJSDOMWindowInstance_PerformanceServerTiming(VM& vm, JSObject*)
4802{
4803 return CustomGetterSetter::create(vm, jsDOMWindow_PerformanceServerTimingConstructor, nullptr);
4804}
4805
4806static bool isEnabledJSDOMWindowInstance_PerformanceServerTiming(JSGlobalObject* globalObject)
4807{
4808 UNUSED_PARAM(globalObject);
4809 return RuntimeEnabledFeatures::sharedFeatures().serverTimingEnabled();
4810}
4811
4812#if ENABLE(RESIZE_OBSERVER)
4813static JSValue createJSDOMWindowInstance_ResizeObserver(VM& vm, JSObject*)
4814{
4815 return CustomGetterSetter::create(vm, jsDOMWindow_ResizeObserverConstructor, nullptr);
4816}
4817
4818static bool isEnabledJSDOMWindowInstance_ResizeObserver(JSGlobalObject* globalObject)
4819{
4820 UNUSED_PARAM(globalObject);
4821 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().resizeObserverEnabled;
4822}
4823#endif
4824
4825#if ENABLE(RESIZE_OBSERVER)
4826static JSValue createJSDOMWindowInstance_ResizeObserverEntry(VM& vm, JSObject*)
4827{
4828 return CustomGetterSetter::create(vm, jsDOMWindow_ResizeObserverEntryConstructor, nullptr);
4829}
4830
4831static bool isEnabledJSDOMWindowInstance_ResizeObserverEntry(JSGlobalObject* globalObject)
4832{
4833 UNUSED_PARAM(globalObject);
4834 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().resizeObserverEnabled;
4835}
4836#endif
4837
4838static JSValue createJSDOMWindowInstance_UndoItem(VM& vm, JSObject*)
4839{
4840 return CustomGetterSetter::create(vm, jsDOMWindow_UndoItemConstructor, nullptr);
4841}
4842
4843static bool isEnabledJSDOMWindowInstance_UndoItem(JSGlobalObject* globalObject)
4844{
4845 UNUSED_PARAM(globalObject);
4846 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().undoManagerAPIEnabled;
4847}
4848
4849static JSValue createJSDOMWindowInstance_UndoManager(VM& vm, JSObject*)
4850{
4851 return CustomGetterSetter::create(vm, jsDOMWindow_UndoManagerConstructor, nullptr);
4852}
4853
4854static bool isEnabledJSDOMWindowInstance_UndoManager(JSGlobalObject* globalObject)
4855{
4856 UNUSED_PARAM(globalObject);
4857 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().undoManagerAPIEnabled;
4858}
4859
4860static JSValue createJSDOMWindowInstance_VisualViewport(VM& vm, JSObject*)
4861{
4862 return CustomGetterSetter::create(vm, jsDOMWindow_VisualViewportConstructor, nullptr);
4863}
4864
4865static bool isEnabledJSDOMWindowInstance_VisualViewport(JSGlobalObject* globalObject)
4866{
4867 UNUSED_PARAM(globalObject);
4868 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().visualViewportAPIEnabled;
4869}
4870
4871#if ENABLE(SERVICE_WORKER)
4872static JSValue createJSDOMWindowInstance_ServiceWorker(VM& vm, JSObject*)
4873{
4874 return CustomGetterSetter::create(vm, jsDOMWindow_ServiceWorkerConstructor, nullptr);
4875}
4876
4877static bool isEnabledJSDOMWindowInstance_ServiceWorker(JSGlobalObject* globalObject)
4878{
4879 UNUSED_PARAM(globalObject);
4880 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && RuntimeEnabledFeatures::sharedFeatures().serviceWorkerEnabled());
4881}
4882#endif
4883
4884#if ENABLE(SERVICE_WORKER)
4885static JSValue createJSDOMWindowInstance_ServiceWorkerContainer(VM& vm, JSObject*)
4886{
4887 return CustomGetterSetter::create(vm, jsDOMWindow_ServiceWorkerContainerConstructor, nullptr);
4888}
4889
4890static bool isEnabledJSDOMWindowInstance_ServiceWorkerContainer(JSGlobalObject* globalObject)
4891{
4892 UNUSED_PARAM(globalObject);
4893 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && RuntimeEnabledFeatures::sharedFeatures().serviceWorkerEnabled());
4894}
4895#endif
4896
4897#if ENABLE(SERVICE_WORKER)
4898static JSValue createJSDOMWindowInstance_ServiceWorkerRegistration(VM& vm, JSObject*)
4899{
4900 return CustomGetterSetter::create(vm, jsDOMWindow_ServiceWorkerRegistrationConstructor, nullptr);
4901}
4902
4903static bool isEnabledJSDOMWindowInstance_ServiceWorkerRegistration(JSGlobalObject* globalObject)
4904{
4905 UNUSED_PARAM(globalObject);
4906 return (jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->isSecureContext() && RuntimeEnabledFeatures::sharedFeatures().serviceWorkerEnabled());
4907}
4908#endif
4909
4910static JSValue createJSDOMWindowInstance_collectMatchingElementsInFlatTree(VM& vm, JSObject* thisObject)
4911{
4912 return JSFunction::create(vm, thisObject->globalObject(), 2, "collectMatchingElementsInFlatTree"_s, jsDOMWindowInstanceFunction_collectMatchingElementsInFlatTree);
4913}
4914
4915static bool isEnabledJSDOMWindowInstance_collectMatchingElementsInFlatTree(JSGlobalObject* globalObject)
4916{
4917 UNUSED_PARAM(globalObject);
4918 return jsCast<JSDOMGlobalObject*>(globalObject)->world().shadowRootIsAlwaysOpen();
4919}
4920
4921static JSValue createJSDOMWindowInstance_matchingElementInFlatTree(VM& vm, JSObject* thisObject)
4922{
4923 return JSFunction::create(vm, thisObject->globalObject(), 2, "matchingElementInFlatTree"_s, jsDOMWindowInstanceFunction_matchingElementInFlatTree);
4924}
4925
4926static bool isEnabledJSDOMWindowInstance_matchingElementInFlatTree(JSGlobalObject* globalObject)
4927{
4928 UNUSED_PARAM(globalObject);
4929 return jsCast<JSDOMGlobalObject*>(globalObject)->world().shadowRootIsAlwaysOpen();
4930}
4931
4932static JSValue createJSDOMWindowInstance_requestIdleCallback(VM& vm, JSObject* thisObject)
4933{
4934 return JSFunction::create(vm, thisObject->globalObject(), 1, "requestIdleCallback"_s, jsDOMWindowInstanceFunction_requestIdleCallback);
4935}
4936
4937static bool isEnabledJSDOMWindowInstance_requestIdleCallback(JSGlobalObject* globalObject)
4938{
4939 UNUSED_PARAM(globalObject);
4940 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().requestIdleCallbackEnabled;
4941}
4942
4943static JSValue createJSDOMWindowInstance_cancelIdleCallback(VM& vm, JSObject* thisObject)
4944{
4945 return JSFunction::create(vm, thisObject->globalObject(), 1, "cancelIdleCallback"_s, jsDOMWindowInstanceFunction_cancelIdleCallback);
4946}
4947
4948static bool isEnabledJSDOMWindowInstance_cancelIdleCallback(JSGlobalObject* globalObject)
4949{
4950 UNUSED_PARAM(globalObject);
4951 return jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext()->settingsValues().requestIdleCallbackEnabled;
4952}
4953
4954static JSValue createJSDOMWindowInstance_createImageBitmap(VM& vm, JSObject* thisObject)
4955{
4956 return JSFunction::create(vm, thisObject->globalObject(), 1, "createImageBitmap"_s, jsDOMWindowInstanceFunction_createImageBitmap);
4957}
4958
4959static bool isEnabledJSDOMWindowInstance_createImageBitmap(JSGlobalObject* globalObject)
4960{
4961 UNUSED_PARAM(globalObject);
4962 return RuntimeEnabledFeatures::sharedFeatures().imageBitmapEnabled();
4963}
4964
4965/* Hash table for Instance */
4966
4967static const struct CompactHashIndex JSDOMWindowInstanceTableIndex[2202] = {
4968 { 866, -1 },
4969 { 596, -1 },
4970 { -1, -1 },
4971 { -1, -1 },
4972 { 319, -1 },
4973 { -1, -1 },
4974 { -1, -1 },
4975 { 663, -1 },
4976 { -1, -1 },
4977 { -1, -1 },
4978 { 878, -1 },
4979 { 311, -1 },
4980 { -1, -1 },
4981 { 658, -1 },
4982 { -1, -1 },
4983 { -1, -1 },
4984 { 825, -1 },
4985 { -1, -1 },
4986 { -1, -1 },
4987 { 452, -1 },
4988 { 327, -1 },
4989 { -1, -1 },
4990 { 489, -1 },
4991 { -1, -1 },
4992 { -1, -1 },
4993 { -1, -1 },
4994 { 115, 2060 },
4995 { -1, -1 },
4996 { -1, -1 },
4997 { -1, -1 },
4998 { -1, -1 },
4999 { -1, -1 },
5000 { -1, -1 },
5001 { 259, -1 },
5002 { -1, -1 },
5003 { 467, -1 },
5004 { 686, -1 },
5005 { 178, -1 },
5006 { 875, -1 },
5007 { -1, -1 },
5008 { -1, -1 },
5009 { -1, -1 },
5010 { -1, -1 },
5011 { -1, -1 },
5012 { -1, -1 },
5013 { 279, -1 },
5014 { 106, 2083 },
5015 { -1, -1 },
5016 { 630, -1 },
5017 { -1, -1 },
5018 { -1, -1 },
5019 { -1, -1 },
5020 { -1, -1 },
5021 { -1, -1 },
5022 { -1, -1 },
5023 { -1, -1 },
5024 { -1, -1 },
5025 { 20, -1 },
5026 { -1, -1 },
5027 { -1, -1 },
5028 { 363, -1 },
5029 { -1, -1 },
5030 { -1, -1 },
5031 { 122, 2069 },
5032 { 768, -1 },
5033 { -1, -1 },
5034 { -1, -1 },
5035 { -1, -1 },
5036 { -1, -1 },
5037 { -1, -1 },
5038 { 468, -1 },
5039 { 581, -1 },
5040 { -1, -1 },
5041 { -1, -1 },
5042 { 473, 2151 },
5043 { 665, -1 },
5044 { -1, -1 },
5045 { 492, -1 },
5046 { -1, -1 },
5047 { -1, -1 },
5048 { -1, -1 },
5049 { -1, -1 },
5050 { 499, 2136 },
5051 { -1, -1 },
5052 { -1, -1 },
5053 { -1, -1 },
5054 { -1, -1 },
5055 { -1, -1 },
5056 { -1, -1 },
5057 { 831, -1 },
5058 { -1, -1 },
5059 { -1, -1 },
5060 { 679, -1 },
5061 { 214, -1 },
5062 { -1, -1 },
5063 { -1, -1 },
5064 { -1, -1 },
5065 { 298, -1 },
5066 { -1, -1 },
5067 { -1, -1 },
5068 { 225, -1 },
5069 { -1, -1 },
5070 { -1, -1 },
5071 { -1, -1 },
5072 { -1, -1 },
5073 { 185, -1 },
5074 { -1, -1 },
5075 { -1, -1 },
5076 { 232, 2074 },
5077 { -1, -1 },
5078 { -1, -1 },
5079 { 706, -1 },
5080 { -1, -1 },
5081 { -1, -1 },
5082 { -1, -1 },
5083 { -1, -1 },
5084 { -1, -1 },
5085 { 717, -1 },
5086 { 442, -1 },
5087 { 543, -1 },
5088 { -1, -1 },
5089 { -1, -1 },
5090 { -1, -1 },
5091 { -1, -1 },
5092 { -1, -1 },
5093 { 292, -1 },
5094 { -1, -1 },
5095 { -1, -1 },
5096 { -1, -1 },
5097 { -1, -1 },
5098 { -1, -1 },
5099 { 27, 2056 },
5100 { 773, -1 },
5101 { -1, -1 },
5102 { 366, 2201 },
5103 { -1, -1 },
5104 { -1, -1 },
5105 { -1, -1 },
5106 { -1, -1 },
5107 { 149, -1 },
5108 { -1, -1 },
5109 { -1, -1 },
5110 { -1, -1 },
5111 { -1, -1 },
5112 { -1, -1 },
5113 { -1, -1 },
5114 { -1, -1 },
5115 { -1, -1 },
5116 { -1, -1 },
5117 { 436, -1 },
5118 { -1, -1 },
5119 { -1, -1 },
5120 { -1, -1 },
5121 { 726, -1 },
5122 { 48, 2072 },
5123 { -1, -1 },
5124 { -1, -1 },
5125 { -1, -1 },
5126 { -1, -1 },
5127 { -1, -1 },
5128 { -1, -1 },
5129 { -1, -1 },
5130 { -1, -1 },
5131 { 837, -1 },
5132 { -1, -1 },
5133 { 354, -1 },
5134 { -1, -1 },
5135 { -1, -1 },
5136 { 66, -1 },
5137 { -1, -1 },
5138 { -1, -1 },
5139 { -1, -1 },
5140 { -1, -1 },
5141 { -1, -1 },
5142 { -1, -1 },
5143 { -1, -1 },
5144 { -1, -1 },
5145 { -1, -1 },
5146 { -1, -1 },
5147 { 57, -1 },
5148 { -1, -1 },
5149 { -1, -1 },
5150 { -1, -1 },
5151 { -1, -1 },
5152 { -1, -1 },
5153 { -1, -1 },
5154 { 425, -1 },
5155 { -1, -1 },
5156 { -1, -1 },
5157 { 633, -1 },
5158 { -1, -1 },
5159 { 42, -1 },
5160 { -1, -1 },
5161 { 651, -1 },
5162 { -1, -1 },
5163 { 146, -1 },
5164 { -1, -1 },
5165 { -1, -1 },
5166 { 814, -1 },
5167 { -1, -1 },
5168 { 234, -1 },
5169 { -1, -1 },
5170 { 353, -1 },
5171 { 642, -1 },
5172 { -1, -1 },
5173 { -1, -1 },
5174 { -1, -1 },
5175 { 643, -1 },
5176 { -1, -1 },
5177 { -1, -1 },
5178 { 218, -1 },
5179 { 302, -1 },
5180 { 687, -1 },
5181 { 33, 2054 },
5182 { -1, -1 },
5183 { -1, -1 },
5184 { -1, -1 },
5185 { -1, -1 },
5186 { -1, -1 },
5187 { -1, -1 },
5188 { -1, -1 },
5189 { -1, -1 },
5190 { 233, -1 },
5191 { 5, -1 },
5192 { -1, -1 },
5193 { -1, -1 },
5194 { -1, -1 },
5195 { -1, -1 },
5196 { 818, -1 },
5197 { -1, -1 },
5198 { -1, -1 },
5199 { 17, 2173 },
5200 { 350, -1 },
5201 { 786, -1 },
5202 { -1, -1 },
5203 { -1, -1 },
5204 { -1, -1 },
5205 { -1, -1 },
5206 { 764, -1 },
5207 { -1, -1 },
5208 { -1, -1 },
5209 { -1, -1 },
5210 { 673, -1 },
5211 { 19, -1 },
5212 { 293, -1 },
5213 { -1, -1 },
5214 { 827, -1 },
5215 { 481, -1 },
5216 { 513, -1 },
5217 { -1, -1 },
5218 { 674, -1 },
5219 { 493, 2127 },
5220 { -1, -1 },
5221 { 854, -1 },
5222 { 582, -1 },
5223 { -1, -1 },
5224 { -1, -1 },
5225 { 678, -1 },
5226 { 108, -1 },
5227 { 557, -1 },
5228 { 154, 2194 },
5229 { -1, -1 },
5230 { 410, -1 },
5231 { -1, -1 },
5232 { 56, -1 },
5233 { 252, -1 },
5234 { -1, -1 },
5235 { -1, -1 },
5236 { -1, -1 },
5237 { -1, -1 },
5238 { 236, 2085 },
5239 { 627, -1 },
5240 { -1, -1 },
5241 { -1, -1 },
5242 { -1, -1 },
5243 { -1, -1 },
5244 { -1, -1 },
5245 { -1, -1 },
5246 { -1, -1 },
5247 { -1, -1 },
5248 { -1, -1 },
5249 { -1, -1 },
5250 { -1, -1 },
5251 { -1, -1 },
5252 { 432, -1 },
5253 { -1, -1 },
5254 { -1, -1 },
5255 { 584, -1 },
5256 { -1, -1 },
5257 { -1, -1 },
5258 { -1, -1 },
5259 { -1, -1 },
5260 { -1, -1 },
5261 { -1, -1 },
5262 { 68, -1 },
5263 { -1, -1 },
5264 { 262, 2122 },
5265 { -1, -1 },
5266 { -1, -1 },
5267 { -1, -1 },
5268 { 272, -1 },
5269 { 224, -1 },
5270 { 132, -1 },
5271 { 551, -1 },
5272 { -1, -1 },
5273 { -1, -1 },
5274 { 134, -1 },
5275 { -1, -1 },
5276 { -1, -1 },
5277 { -1, -1 },
5278 { -1, -1 },
5279 { 59, 2052 },
5280 { -1, -1 },
5281 { -1, -1 },
5282 { -1, -1 },
5283 { -1, -1 },
5284 { -1, -1 },
5285 { -1, -1 },
5286 { -1, -1 },
5287 { 578, -1 },
5288 { -1, -1 },
5289 { -1, -1 },
5290 { 657, -1 },
5291 { -1, -1 },
5292 { -1, -1 },
5293 { -1, -1 },
5294 { -1, -1 },
5295 { -1, -1 },
5296 { -1, -1 },
5297 { 603, -1 },
5298 { -1, -1 },
5299 { 613, -1 },
5300 { -1, -1 },
5301 { -1, -1 },
5302 { 701, -1 },
5303 { -1, -1 },
5304 { -1, -1 },
5305 { -1, -1 },
5306 { -1, -1 },
5307 { -1, -1 },
5308 { -1, -1 },
5309 { -1, -1 },
5310 { -1, -1 },
5311 { -1, -1 },
5312 { -1, -1 },
5313 { -1, -1 },
5314 { -1, -1 },
5315 { -1, -1 },
5316 { -1, -1 },
5317 { 388, -1 },
5318 { -1, -1 },
5319 { -1, -1 },
5320 { -1, -1 },
5321 { -1, -1 },
5322 { -1, -1 },
5323 { 175, -1 },
5324 { -1, -1 },
5325 { -1, -1 },
5326 { -1, -1 },
5327 { -1, -1 },
5328 { -1, -1 },
5329 { 515, -1 },
5330 { -1, -1 },
5331 { -1, -1 },
5332 { -1, -1 },
5333 { -1, -1 },
5334 { -1, -1 },
5335 { -1, -1 },
5336 { -1, -1 },
5337 { -1, -1 },
5338 { -1, -1 },
5339 { -1, -1 },
5340 { -1, -1 },
5341 { 285, 2133 },
5342 { -1, -1 },
5343 { -1, -1 },
5344 { -1, -1 },
5345 { -1, -1 },
5346 { 763, -1 },
5347 { -1, -1 },
5348 { 522, 2124 },
5349 { -1, -1 },
5350 { -1, -1 },
5351 { -1, -1 },
5352 { -1, -1 },
5353 { 195, -1 },
5354 { -1, -1 },
5355 { -1, -1 },
5356 { -1, -1 },
5357 { -1, -1 },
5358 { -1, -1 },
5359 { -1, -1 },
5360 { -1, -1 },
5361 { -1, -1 },
5362 { -1, -1 },
5363 { -1, -1 },
5364 { -1, -1 },
5365 { -1, -1 },
5366 { -1, -1 },
5367 { -1, -1 },
5368 { -1, -1 },
5369 { 621, -1 },
5370 { -1, -1 },
5371 { -1, -1 },
5372 { -1, -1 },
5373 { 207, 2102 },
5374 { -1, -1 },
5375 { -1, -1 },
5376 { -1, -1 },
5377 { 274, -1 },
5378 { -1, -1 },
5379 { -1, -1 },
5380 { 38, -1 },
5381 { 568, 2197 },
5382 { -1, -1 },
5383 { 509, -1 },
5384 { 237, -1 },
5385 { -1, -1 },
5386 { -1, -1 },
5387 { -1, -1 },
5388 { -1, -1 },
5389 { 88, 2132 },
5390 { -1, -1 },
5391 { 477, -1 },
5392 { -1, -1 },
5393 { -1, -1 },
5394 { 174, -1 },
5395 { -1, -1 },
5396 { 420, -1 },
5397 { -1, -1 },
5398 { 303, -1 },
5399 { 490, -1 },
5400 { 405, -1 },
5401 { -1, -1 },
5402 { -1, -1 },
5403 { -1, -1 },
5404 { 393, -1 },
5405 { -1, -1 },
5406 { -1, -1 },
5407 { -1, -1 },
5408 { -1, -1 },
5409 { -1, -1 },
5410 { 69, 2082 },
5411 { -1, -1 },
5412 { -1, -1 },
5413 { 880, -1 },
5414 { 119, 2144 },
5415 { 514, -1 },
5416 { -1, -1 },
5417 { 517, -1 },
5418 { 128, -1 },
5419 { -1, -1 },
5420 { 264, -1 },
5421 { 220, -1 },
5422 { -1, -1 },
5423 { -1, -1 },
5424 { 395, -1 },
5425 { -1, -1 },
5426 { 821, -1 },
5427 { -1, -1 },
5428 { -1, -1 },
5429 { -1, -1 },
5430 { -1, -1 },
5431 { 537, 2187 },
5432 { -1, -1 },
5433 { -1, -1 },
5434 { 724, -1 },
5435 { -1, -1 },
5436 { 440, -1 },
5437 { -1, -1 },
5438 { -1, -1 },
5439 { 676, -1 },
5440 { -1, -1 },
5441 { 291, 2100 },
5442 { -1, -1 },
5443 { 422, -1 },
5444 { -1, -1 },
5445 { 503, -1 },
5446 { 840, -1 },
5447 { -1, -1 },
5448 { -1, -1 },
5449 { -1, -1 },
5450 { -1, -1 },
5451 { 26, -1 },
5452 { 466, -1 },
5453 { -1, -1 },
5454 { 591, 2169 },
5455 { -1, -1 },
5456 { -1, -1 },
5457 { 75, 2101 },
5458 { -1, -1 },
5459 { -1, -1 },
5460 { -1, -1 },
5461 { 343, -1 },
5462 { -1, -1 },
5463 { 367, -1 },
5464 { 433, -1 },
5465 { -1, -1 },
5466 { -1, -1 },
5467 { 381, -1 },
5468 { -1, -1 },
5469 { 269, -1 },
5470 { 112, -1 },
5471 { -1, -1 },
5472 { 424, 2099 },
5473 { -1, -1 },
5474 { -1, -1 },
5475 { -1, -1 },
5476 { -1, -1 },
5477 { -1, -1 },
5478 { -1, -1 },
5479 { 745, -1 },
5480 { 267, -1 },
5481 { -1, -1 },
5482 { 315, 2142 },
5483 { 570, -1 },
5484 { 622, -1 },
5485 { -1, -1 },
5486 { 47, -1 },
5487 { -1, -1 },
5488 { -1, -1 },
5489 { -1, -1 },
5490 { 534, -1 },
5491 { 523, -1 },
5492 { -1, -1 },
5493 { 501, -1 },
5494 { 810, -1 },
5495 { -1, -1 },
5496 { -1, -1 },
5497 { 326, -1 },
5498 { -1, -1 },
5499 { -1, -1 },
5500 { -1, -1 },
5501 { -1, -1 },
5502 { 853, -1 },
5503 { -1, -1 },
5504 { 809, -1 },
5505 { -1, -1 },
5506 { 84, -1 },
5507 { -1, -1 },
5508 { 859, -1 },
5509 { -1, -1 },
5510 { -1, -1 },
5511 { -1, -1 },
5512 { 520, -1 },
5513 { 230, 2174 },
5514 { 427, 2116 },
5515 { -1, -1 },
5516 { -1, -1 },
5517 { 117, -1 },
5518 { 792, -1 },
5519 { -1, -1 },
5520 { -1, -1 },
5521 { -1, -1 },
5522 { 417, -1 },
5523 { 29, -1 },
5524 { -1, -1 },
5525 { 779, -1 },
5526 { -1, -1 },
5527 { -1, -1 },
5528 { -1, -1 },
5529 { -1, -1 },
5530 { -1, -1 },
5531 { -1, -1 },
5532 { -1, -1 },
5533 { -1, -1 },
5534 { 304, 2119 },
5535 { -1, -1 },
5536 { 511, -1 },
5537 { -1, -1 },
5538 { 462, -1 },
5539 { -1, -1 },
5540 { -1, -1 },
5541 { 74, -1 },
5542 { -1, -1 },
5543 { -1, -1 },
5544 { 111, -1 },
5545 { 89, -1 },
5546 { 689, -1 },
5547 { -1, -1 },
5548 { 564, -1 },
5549 { 429, -1 },
5550 { 783, -1 },
5551 { -1, -1 },
5552 { -1, -1 },
5553 { -1, -1 },
5554 { -1, -1 },
5555 { -1, -1 },
5556 { 240, -1 },
5557 { 631, -1 },
5558 { -1, -1 },
5559 { -1, -1 },
5560 { 86, -1 },
5561 { 781, -1 },
5562 { -1, -1 },
5563 { 137, -1 },
5564 { -1, -1 },
5565 { 72, -1 },
5566 { -1, -1 },
5567 { 271, -1 },
5568 { -1, -1 },
5569 { -1, -1 },
5570 { 50, 2064 },
5571 { 118, -1 },
5572 { -1, -1 },
5573 { 192, -1 },
5574 { -1, -1 },
5575 { -1, -1 },
5576 { -1, -1 },
5577 { -1, -1 },
5578 { 659, -1 },
5579 { 549, -1 },
5580 { 435, 2177 },
5581 { -1, -1 },
5582 { -1, -1 },
5583 { -1, -1 },
5584 { 23, -1 },
5585 { -1, -1 },
5586 { -1, -1 },
5587 { 413, 2143 },
5588 { -1, -1 },
5589 { 126, -1 },
5590 { -1, -1 },
5591 { 169, 2095 },
5592 { 338, -1 },
5593 { -1, -1 },
5594 { 299, 2103 },
5595 { -1, -1 },
5596 { -1, -1 },
5597 { 150, -1 },
5598 { 153, -1 },
5599 { -1, -1 },
5600 { -1, -1 },
5601 { -1, -1 },
5602 { -1, -1 },
5603 { 804, -1 },
5604 { 40, 2050 },
5605 { 221, -1 },
5606 { -1, -1 },
5607 { -1, -1 },
5608 { -1, -1 },
5609 { 609, 2192 },
5610 { -1, -1 },
5611 { 176, 2165 },
5612 { -1, -1 },
5613 { 774, -1 },
5614 { -1, -1 },
5615 { -1, -1 },
5616 { 152, 2070 },
5617 { 426, -1 },
5618 { -1, -1 },
5619 { 648, -1 },
5620 { -1, -1 },
5621 { 505, -1 },
5622 { -1, -1 },
5623 { -1, -1 },
5624 { -1, -1 },
5625 { -1, -1 },
5626 { -1, -1 },
5627 { -1, -1 },
5628 { -1, -1 },
5629 { -1, -1 },
5630 { -1, -1 },
5631 { 719, -1 },
5632 { -1, -1 },
5633 { -1, -1 },
5634 { 822, -1 },
5635 { -1, -1 },
5636 { -1, -1 },
5637 { 142, -1 },
5638 { -1, -1 },
5639 { 519, -1 },
5640 { -1, -1 },
5641 { -1, -1 },
5642 { -1, -1 },
5643 { 625, -1 },
5644 { -1, -1 },
5645 { -1, -1 },
5646 { -1, -1 },
5647 { 736, -1 },
5648 { -1, -1 },
5649 { -1, -1 },
5650 { 330, -1 },
5651 { 727, -1 },
5652 { 471, -1 },
5653 { -1, -1 },
5654 { -1, -1 },
5655 { -1, -1 },
5656 { -1, -1 },
5657 { 309, -1 },
5658 { -1, -1 },
5659 { 485, -1 },
5660 { 536, -1 },
5661 { -1, -1 },
5662 { -1, -1 },
5663 { 96, 2051 },
5664 { 601, -1 },
5665 { 79, -1 },
5666 { 408, 2126 },
5667 { -1, -1 },
5668 { -1, -1 },
5669 { 478, -1 },
5670 { -1, -1 },
5671 { -1, -1 },
5672 { 431, -1 },
5673 { -1, -1 },
5674 { -1, -1 },
5675 { 567, -1 },
5676 { -1, -1 },
5677 { 377, -1 },
5678 { -1, -1 },
5679 { -1, -1 },
5680 { -1, -1 },
5681 { 646, -1 },
5682 { 672, -1 },
5683 { -1, -1 },
5684 { -1, -1 },
5685 { 6, 2087 },
5686 { -1, -1 },
5687 { 28, 2048 },
5688 { 669, -1 },
5689 { -1, -1 },
5690 { 324, -1 },
5691 { 716, -1 },
5692 { -1, -1 },
5693 { -1, -1 },
5694 { 640, -1 },
5695 { 604, -1 },
5696 { -1, -1 },
5697 { -1, -1 },
5698 { -1, -1 },
5699 { 328, -1 },
5700 { -1, -1 },
5701 { 572, -1 },
5702 { -1, -1 },
5703 { -1, -1 },
5704 { -1, -1 },
5705 { 346, -1 },
5706 { -1, -1 },
5707 { 626, -1 },
5708 { 709, -1 },
5709 { -1, -1 },
5710 { 691, -1 },
5711 { 710, -1 },
5712 { -1, -1 },
5713 { 166, -1 },
5714 { 49, -1 },
5715 { 355, -1 },
5716 { -1, -1 },
5717 { -1, -1 },
5718 { -1, -1 },
5719 { -1, -1 },
5720 { 325, -1 },
5721 { -1, -1 },
5722 { 449, -1 },
5723 { -1, -1 },
5724 { -1, -1 },
5725 { 861, -1 },
5726 { 580, -1 },
5727 { 446, -1 },
5728 { -1, -1 },
5729 { -1, -1 },
5730 { 239, 2079 },
5731 { 335, -1 },
5732 { 9, -1 },
5733 { -1, -1 },
5734 { -1, -1 },
5735 { 579, -1 },
5736 { -1, -1 },
5737 { -1, -1 },
5738 { -1, -1 },
5739 { -1, -1 },
5740 { 164, -1 },
5741 { -1, -1 },
5742 { -1, -1 },
5743 { 208, -1 },
5744 { -1, -1 },
5745 { -1, -1 },
5746 { -1, -1 },
5747 { -1, -1 },
5748 { -1, -1 },
5749 { 36, -1 },
5750 { -1, -1 },
5751 { 488, 2152 },
5752 { 13, 2066 },
5753 { -1, -1 },
5754 { -1, -1 },
5755 { -1, -1 },
5756 { 378, -1 },
5757 { 71, 2058 },
5758 { 107, -1 },
5759 { -1, -1 },
5760 { -1, -1 },
5761 { -1, -1 },
5762 { 602, -1 },
5763 { 828, -1 },
5764 { -1, -1 },
5765 { -1, -1 },
5766 { -1, -1 },
5767 { -1, -1 },
5768 { -1, -1 },
5769 { -1, -1 },
5770 { -1, -1 },
5771 { -1, -1 },
5772 { 542, -1 },
5773 { -1, -1 },
5774 { -1, -1 },
5775 { -1, -1 },
5776 { 64, 2055 },
5777 { 400, -1 },
5778 { -1, -1 },
5779 { -1, -1 },
5780 { -1, -1 },
5781 { -1, -1 },
5782 { -1, -1 },
5783 { -1, -1 },
5784 { -1, -1 },
5785 { -1, -1 },
5786 { -1, -1 },
5787 { -1, -1 },
5788 { 588, -1 },
5789 { -1, -1 },
5790 { -1, -1 },
5791 { -1, -1 },
5792 { -1, -1 },
5793 { -1, -1 },
5794 { -1, -1 },
5795 { -1, -1 },
5796 { 114, -1 },
5797 { 375, -1 },
5798 { -1, -1 },
5799 { -1, -1 },
5800 { -1, -1 },
5801 { -1, -1 },
5802 { -1, -1 },
5803 { 231, 2150 },
5804 { -1, -1 },
5805 { -1, -1 },
5806 { -1, -1 },
5807 { 246, -1 },
5808 { -1, -1 },
5809 { 280, -1 },
5810 { 550, -1 },
5811 { -1, -1 },
5812 { -1, -1 },
5813 { -1, -1 },
5814 { -1, -1 },
5815 { 61, -1 },
5816 { -1, -1 },
5817 { 748, -1 },
5818 { -1, -1 },
5819 { -1, -1 },
5820 { -1, -1 },
5821 { -1, -1 },
5822 { 372, -1 },
5823 { -1, -1 },
5824 { 760, -1 },
5825 { 129, 2135 },
5826 { 147, -1 },
5827 { -1, -1 },
5828 { 93, -1 },
5829 { -1, -1 },
5830 { 135, -1 },
5831 { -1, -1 },
5832 { -1, -1 },
5833 { -1, -1 },
5834 { -1, -1 },
5835 { -1, -1 },
5836 { 811, -1 },
5837 { 0, -1 },
5838 { 518, -1 },
5839 { 441, -1 },
5840 { -1, -1 },
5841 { 463, -1 },
5842 { -1, -1 },
5843 { 136, -1 },
5844 { -1, -1 },
5845 { -1, -1 },
5846 { -1, -1 },
5847 { 320, 2159 },
5848 { -1, -1 },
5849 { -1, -1 },
5850 { 165, -1 },
5851 { -1, -1 },
5852 { -1, -1 },
5853 { -1, -1 },
5854 { -1, -1 },
5855 { 695, -1 },
5856 { -1, -1 },
5857 { -1, -1 },
5858 { 290, -1 },
5859 { -1, -1 },
5860 { 212, -1 },
5861 { -1, -1 },
5862 { 41, -1 },
5863 { -1, -1 },
5864 { -1, -1 },
5865 { -1, -1 },
5866 { -1, -1 },
5867 { 39, -1 },
5868 { -1, -1 },
5869 { -1, -1 },
5870 { -1, -1 },
5871 { -1, -1 },
5872 { -1, -1 },
5873 { -1, -1 },
5874 { -1, -1 },
5875 { 265, -1 },
5876 { -1, -1 },
5877 { -1, -1 },
5878 { -1, -1 },
5879 { 312, -1 },
5880 { -1, -1 },
5881 { -1, -1 },
5882 { -1, -1 },
5883 { -1, -1 },
5884 { -1, -1 },
5885 { -1, -1 },
5886 { -1, -1 },
5887 { -1, -1 },
5888 { -1, -1 },
5889 { -1, -1 },
5890 { -1, -1 },
5891 { -1, -1 },
5892 { -1, -1 },
5893 { -1, -1 },
5894 { -1, -1 },
5895 { -1, -1 },
5896 { 571, -1 },
5897 { 705, -1 },
5898 { -1, -1 },
5899 { -1, -1 },
5900 { -1, -1 },
5901 { -1, -1 },
5902 { 171, -1 },
5903 { -1, -1 },
5904 { 99, 2093 },
5905 { -1, -1 },
5906 { -1, -1 },
5907 { 418, -1 },
5908 { -1, -1 },
5909 { 260, -1 },
5910 { -1, -1 },
5911 { -1, -1 },
5912 { 845, -1 },
5913 { -1, -1 },
5914 { 883, -1 },
5915 { -1, -1 },
5916 { 102, 2065 },
5917 { -1, -1 },
5918 { -1, -1 },
5919 { -1, -1 },
5920 { 857, -1 },
5921 { 855, -1 },
5922 { -1, -1 },
5923 { -1, -1 },
5924 { -1, -1 },
5925 { -1, -1 },
5926 { -1, -1 },
5927 { -1, -1 },
5928 { -1, -1 },
5929 { -1, -1 },
5930 { -1, -1 },
5931 { 677, -1 },
5932 { 414, -1 },
5933 { -1, -1 },
5934 { -1, -1 },
5935 { -1, -1 },
5936 { 795, -1 },
5937 { 694, -1 },
5938 { -1, -1 },
5939 { -1, -1 },
5940 { -1, -1 },
5941 { -1, -1 },
5942 { -1, -1 },
5943 { 282, 2181 },
5944 { -1, -1 },
5945 { -1, -1 },
5946 { -1, -1 },
5947 { -1, -1 },
5948 { -1, -1 },
5949 { -1, -1 },
5950 { 342, -1 },
5951 { 544, -1 },
5952 { 668, -1 },
5953 { -1, -1 },
5954 { -1, -1 },
5955 { -1, -1 },
5956 { 25, -1 },
5957 { -1, -1 },
5958 { -1, -1 },
5959 { -1, -1 },
5960 { -1, -1 },
5961 { -1, -1 },
5962 { -1, -1 },
5963 { 205, -1 },
5964 { 620, -1 },
5965 { -1, -1 },
5966 { -1, -1 },
5967 { -1, -1 },
5968 { 725, 2178 },
5969 { -1, -1 },
5970 { 209, -1 },
5971 { -1, -1 },
5972 { -1, -1 },
5973 { 870, -1 },
5974 { 703, -1 },
5975 { -1, -1 },
5976 { -1, -1 },
5977 { 460, -1 },
5978 { -1, -1 },
5979 { -1, -1 },
5980 { -1, -1 },
5981 { -1, -1 },
5982 { 37, -1 },
5983 { -1, -1 },
5984 { -1, -1 },
5985 { 746, -1 },
5986 { -1, -1 },
5987 { -1, -1 },
5988 { 296, 2164 },
5989 { -1, -1 },
5990 { 121, 2062 },
5991 { 451, 2117 },
5992 { -1, -1 },
5993 { -1, -1 },
5994 { 812, -1 },
5995 { -1, -1 },
5996 { -1, -1 },
5997 { -1, -1 },
5998 { -1, -1 },
5999 { -1, -1 },
6000 { 15, -1 },
6001 { -1, -1 },
6002 { -1, -1 },
6003 { 524, 2200 },
6004 { 656, -1 },
6005 { -1, -1 },
6006 { -1, -1 },
6007 { -1, -1 },
6008 { -1, -1 },
6009 { -1, -1 },
6010 { -1, -1 },
6011 { -1, -1 },
6012 { -1, -1 },
6013 { 101, -1 },
6014 { 755, -1 },
6015 { -1, -1 },
6016 { -1, -1 },
6017 { 155, 2140 },
6018 { -1, -1 },
6019 { -1, -1 },
6020 { -1, -1 },
6021 { -1, -1 },
6022 { -1, -1 },
6023 { -1, -1 },
6024 { -1, -1 },
6025 { 199, -1 },
6026 { -1, -1 },
6027 { 80, 2170 },
6028 { 8, -1 },
6029 { 52, 2068 },
6030 { 85, -1 },
6031 { 693, -1 },
6032 { -1, -1 },
6033 { -1, -1 },
6034 { -1, -1 },
6035 { 130, -1 },
6036 { -1, -1 },
6037 { -1, -1 },
6038 { -1, -1 },
6039 { -1, -1 },
6040 { -1, -1 },
6041 { 16, -1 },
6042 { -1, -1 },
6043 { 313, -1 },
6044 { 243, -1 },
6045 { -1, -1 },
6046 { 409, 2180 },
6047 { 754, -1 },
6048 { 450, -1 },
6049 { 277, 2131 },
6050 { -1, -1 },
6051 { -1, -1 },
6052 { 321, -1 },
6053 { -1, -1 },
6054 { -1, -1 },
6055 { 283, 2111 },
6056 { -1, -1 },
6057 { 368, -1 },
6058 { -1, -1 },
6059 { 560, -1 },
6060 { -1, -1 },
6061 { -1, -1 },
6062 { -1, -1 },
6063 { -1, -1 },
6064 { 480, -1 },
6065 { -1, -1 },
6066 { 103, -1 },
6067 { -1, -1 },
6068 { -1, -1 },
6069 { -1, -1 },
6070 { -1, -1 },
6071 { 352, -1 },
6072 { 349, -1 },
6073 { -1, -1 },
6074 { 365, -1 },
6075 { 2, 2098 },
6076 { -1, -1 },
6077 { 76, -1 },
6078 { 577, -1 },
6079 { 852, -1 },
6080 { 91, -1 },
6081 { -1, -1 },
6082 { -1, -1 },
6083 { -1, -1 },
6084 { -1, -1 },
6085 { -1, -1 },
6086 { 826, -1 },
6087 { -1, -1 },
6088 { 495, 2185 },
6089 { -1, -1 },
6090 { 351, 2130 },
6091 { -1, -1 },
6092 { 255, -1 },
6093 { 284, -1 },
6094 { -1, -1 },
6095 { 145, 2121 },
6096 { -1, -1 },
6097 { 341, 2186 },
6098 { 527, -1 },
6099 { -1, -1 },
6100 { -1, -1 },
6101 { 217, -1 },
6102 { 11, -1 },
6103 { -1, -1 },
6104 { -1, -1 },
6105 { 583, -1 },
6106 { -1, -1 },
6107 { -1, -1 },
6108 { 46, -1 },
6109 { 512, -1 },
6110 { 683, -1 },
6111 { -1, -1 },
6112 { 317, -1 },
6113 { -1, -1 },
6114 { -1, -1 },
6115 { 278, -1 },
6116 { -1, -1 },
6117 { -1, -1 },
6118 { -1, -1 },
6119 { -1, -1 },
6120 { -1, -1 },
6121 { -1, -1 },
6122 { -1, -1 },
6123 { 55, 2059 },
6124 { -1, -1 },
6125 { -1, -1 },
6126 { -1, -1 },
6127 { -1, -1 },
6128 { 161, 2092 },
6129 { 867, -1 },
6130 { -1, -1 },
6131 { 389, -1 },
6132 { -1, -1 },
6133 { -1, -1 },
6134 { -1, -1 },
6135 { 817, -1 },
6136 { 62, 2057 },
6137 { 595, -1 },
6138 { -1, -1 },
6139 { -1, -1 },
6140 { -1, -1 },
6141 { -1, -1 },
6142 { 645, -1 },
6143 { -1, -1 },
6144 { 104, -1 },
6145 { 3, -1 },
6146 { -1, -1 },
6147 { -1, -1 },
6148 { -1, -1 },
6149 { -1, -1 },
6150 { -1, -1 },
6151 { 170, -1 },
6152 { 555, -1 },
6153 { -1, -1 },
6154 { -1, -1 },
6155 { -1, -1 },
6156 { -1, -1 },
6157 { 465, -1 },
6158 { -1, -1 },
6159 { -1, -1 },
6160 { -1, -1 },
6161 { 575, -1 },
6162 { -1, -1 },
6163 { -1, -1 },
6164 { -1, -1 },
6165 { 254, -1 },
6166 { 881, -1 },
6167 { 168, -1 },
6168 { -1, -1 },
6169 { -1, -1 },
6170 { -1, -1 },
6171 { -1, -1 },
6172 { -1, -1 },
6173 { -1, -1 },
6174 { 92, -1 },
6175 { 610, -1 },
6176 { -1, -1 },
6177 { -1, -1 },
6178 { 660, 2158 },
6179 { -1, -1 },
6180 { -1, -1 },
6181 { 751, -1 },
6182 { -1, -1 },
6183 { 585, -1 },
6184 { -1, -1 },
6185 { 838, -1 },
6186 { -1, -1 },
6187 { -1, -1 },
6188 { -1, -1 },
6189 { 369, -1 },
6190 { -1, -1 },
6191 { -1, -1 },
6192 { 229, -1 },
6193 { -1, -1 },
6194 { -1, -1 },
6195 { -1, -1 },
6196 { -1, -1 },
6197 { 399, -1 },
6198 { 67, 2063 },
6199 { -1, -1 },
6200 { 334, 2107 },
6201 { -1, -1 },
6202 { 196, -1 },
6203 { -1, -1 },
6204 { -1, -1 },
6205 { -1, -1 },
6206 { -1, -1 },
6207 { -1, -1 },
6208 { 140, -1 },
6209 { 832, -1 },
6210 { 253, 2090 },
6211 { -1, -1 },
6212 { 44, -1 },
6213 { -1, -1 },
6214 { -1, -1 },
6215 { -1, -1 },
6216 { 141, -1 },
6217 { -1, -1 },
6218 { -1, -1 },
6219 { -1, -1 },
6220 { -1, -1 },
6221 { -1, -1 },
6222 { 384, -1 },
6223 { -1, -1 },
6224 { -1, -1 },
6225 { -1, -1 },
6226 { -1, -1 },
6227 { -1, -1 },
6228 { -1, -1 },
6229 { -1, -1 },
6230 { -1, -1 },
6231 { -1, -1 },
6232 { -1, -1 },
6233 { 228, -1 },
6234 { -1, -1 },
6235 { 30, -1 },
6236 { -1, -1 },
6237 { -1, -1 },
6238 { 307, -1 },
6239 { 364, -1 },
6240 { -1, -1 },
6241 { 241, 2129 },
6242 { 879, -1 },
6243 { -1, -1 },
6244 { -1, -1 },
6245 { 110, -1 },
6246 { -1, -1 },
6247 { 263, 2110 },
6248 { -1, -1 },
6249 { -1, -1 },
6250 { 160, -1 },
6251 { -1, -1 },
6252 { -1, -1 },
6253 { 131, -1 },
6254 { -1, -1 },
6255 { 323, -1 },
6256 { -1, -1 },
6257 { -1, -1 },
6258 { -1, -1 },
6259 { -1, -1 },
6260 { 682, -1 },
6261 { 738, -1 },
6262 { -1, -1 },
6263 { 43, 2120 },
6264 { -1, -1 },
6265 { -1, -1 },
6266 { -1, -1 },
6267 { 863, -1 },
6268 { 486, -1 },
6269 { 379, -1 },
6270 { -1, -1 },
6271 { -1, -1 },
6272 { 472, -1 },
6273 { -1, -1 },
6274 { -1, -1 },
6275 { -1, -1 },
6276 { -1, -1 },
6277 { 295, -1 },
6278 { -1, -1 },
6279 { 830, -1 },
6280 { -1, -1 },
6281 { 566, -1 },
6282 { 287, -1 },
6283 { -1, -1 },
6284 { 219, -1 },
6285 { -1, -1 },
6286 { 1, 2091 },
6287 { -1, -1 },
6288 { -1, -1 },
6289 { 484, 2128 },
6290 { 474, -1 },
6291 { 360, 2108 },
6292 { -1, -1 },
6293 { 177, -1 },
6294 { 476, 2168 },
6295 { 574, -1 },
6296 { -1, -1 },
6297 { -1, -1 },
6298 { -1, -1 },
6299 { -1, -1 },
6300 { 699, -1 },
6301 { -1, -1 },
6302 { -1, -1 },
6303 { -1, -1 },
6304 { -1, -1 },
6305 { -1, -1 },
6306 { -1, -1 },
6307 { 789, -1 },
6308 { -1, -1 },
6309 { 664, -1 },
6310 { -1, -1 },
6311 { 791, -1 },
6312 { -1, -1 },
6313 { 644, -1 },
6314 { -1, -1 },
6315 { -1, -1 },
6316 { 256, -1 },
6317 { -1, -1 },
6318 { -1, -1 },
6319 { 788, 2193 },
6320 { -1, -1 },
6321 { -1, -1 },
6322 { 95, -1 },
6323 { -1, -1 },
6324 { 599, 2172 },
6325 { -1, -1 },
6326 { 297, 2076 },
6327 { -1, -1 },
6328 { -1, -1 },
6329 { -1, -1 },
6330 { -1, -1 },
6331 { 697, 2156 },
6332 { 447, -1 },
6333 { -1, -1 },
6334 { -1, -1 },
6335 { -1, -1 },
6336 { -1, -1 },
6337 { -1, -1 },
6338 { -1, -1 },
6339 { -1, -1 },
6340 { -1, -1 },
6341 { 713, -1 },
6342 { 275, -1 },
6343 { 608, -1 },
6344 { -1, -1 },
6345 { 248, -1 },
6346 { -1, -1 },
6347 { -1, -1 },
6348 { 728, -1 },
6349 { -1, -1 },
6350 { 158, -1 },
6351 { -1, -1 },
6352 { -1, -1 },
6353 { 358, 2081 },
6354 { 184, 2123 },
6355 { -1, -1 },
6356 { -1, -1 },
6357 { 404, -1 },
6358 { -1, -1 },
6359 { 439, -1 },
6360 { -1, -1 },
6361 { -1, -1 },
6362 { -1, -1 },
6363 { -1, -1 },
6364 { -1, -1 },
6365 { -1, -1 },
6366 { 526, -1 },
6367 { -1, -1 },
6368 { 390, -1 },
6369 { 506, -1 },
6370 { -1, -1 },
6371 { -1, -1 },
6372 { 723, -1 },
6373 { 251, -1 },
6374 { 401, -1 },
6375 { 339, -1 },
6376 { -1, -1 },
6377 { -1, -1 },
6378 { -1, -1 },
6379 { 823, -1 },
6380 { -1, -1 },
6381 { -1, -1 },
6382 { 539, -1 },
6383 { 752, -1 },
6384 { -1, -1 },
6385 { -1, -1 },
6386 { -1, -1 },
6387 { -1, -1 },
6388 { -1, -1 },
6389 { -1, -1 },
6390 { -1, -1 },
6391 { -1, -1 },
6392 { 593, -1 },
6393 { -1, -1 },
6394 { -1, -1 },
6395 { -1, -1 },
6396 { -1, -1 },
6397 { -1, -1 },
6398 { -1, -1 },
6399 { 540, 2125 },
6400 { 268, -1 },
6401 { -1, -1 },
6402 { -1, -1 },
6403 { 494, -1 },
6404 { 124, 2157 },
6405 { 587, 2155 },
6406 { 197, -1 },
6407 { -1, -1 },
6408 { 423, -1 },
6409 { -1, -1 },
6410 { 403, -1 },
6411 { 182, -1 },
6412 { -1, -1 },
6413 { 394, -1 },
6414 { -1, -1 },
6415 { -1, -1 },
6416 { -1, -1 },
6417 { 261, -1 },
6418 { -1, -1 },
6419 { -1, -1 },
6420 { -1, -1 },
6421 { -1, -1 },
6422 { -1, -1 },
6423 { -1, -1 },
6424 { 188, 2182 },
6425 { -1, -1 },
6426 { -1, -1 },
6427 { 116, -1 },
6428 { 332, -1 },
6429 { -1, -1 },
6430 { -1, -1 },
6431 { -1, -1 },
6432 { 856, -1 },
6433 { -1, -1 },
6434 { 839, -1 },
6435 { 675, -1 },
6436 { -1, -1 },
6437 { -1, -1 },
6438 { -1, -1 },
6439 { -1, -1 },
6440 { 242, -1 },
6441 { -1, -1 },
6442 { 359, 2080 },
6443 { -1, -1 },
6444 { 73, -1 },
6445 { -1, -1 },
6446 { 611, -1 },
6447 { -1, -1 },
6448 { -1, -1 },
6449 { -1, -1 },
6450 { -1, -1 },
6451 { 758, -1 },
6452 { 179, -1 },
6453 { -1, -1 },
6454 { 370, -1 },
6455 { -1, -1 },
6456 { 318, -1 },
6457 { 623, -1 },
6458 { 482, -1 },
6459 { 762, -1 },
6460 { 667, -1 },
6461 { -1, -1 },
6462 { -1, -1 },
6463 { -1, -1 },
6464 { -1, -1 },
6465 { 222, -1 },
6466 { 70, -1 },
6467 { -1, -1 },
6468 { -1, -1 },
6469 { -1, -1 },
6470 { 305, -1 },
6471 { 347, -1 },
6472 { 159, -1 },
6473 { 573, -1 },
6474 { -1, -1 },
6475 { -1, -1 },
6476 { 600, -1 },
6477 { -1, -1 },
6478 { -1, -1 },
6479 { -1, -1 },
6480 { -1, -1 },
6481 { -1, -1 },
6482 { 688, -1 },
6483 { 7, -1 },
6484 { 382, -1 },
6485 { 386, -1 },
6486 { -1, -1 },
6487 { 757, -1 },
6488 { 362, -1 },
6489 { -1, -1 },
6490 { 590, -1 },
6491 { -1, -1 },
6492 { -1, -1 },
6493 { -1, -1 },
6494 { 329, -1 },
6495 { -1, -1 },
6496 { -1, -1 },
6497 { 172, -1 },
6498 { -1, -1 },
6499 { -1, -1 },
6500 { -1, -1 },
6501 { -1, -1 },
6502 { -1, -1 },
6503 { -1, -1 },
6504 { -1, -1 },
6505 { -1, -1 },
6506 { 306, -1 },
6507 { 516, 2112 },
6508 { 310, 2077 },
6509 { 653, -1 },
6510 { -1, -1 },
6511 { 794, -1 },
6512 { -1, -1 },
6513 { -1, -1 },
6514 { -1, -1 },
6515 { -1, -1 },
6516 { 308, -1 },
6517 { -1, -1 },
6518 { -1, -1 },
6519 { -1, -1 },
6520 { -1, -1 },
6521 { 491, -1 },
6522 { -1, -1 },
6523 { -1, -1 },
6524 { -1, -1 },
6525 { 737, -1 },
6526 { 871, -1 },
6527 { -1, -1 },
6528 { 198, 2094 },
6529 { 720, -1 },
6530 { -1, -1 },
6531 { -1, -1 },
6532 { -1, -1 },
6533 { -1, -1 },
6534 { 548, -1 },
6535 { -1, -1 },
6536 { 498, -1 },
6537 { -1, -1 },
6538 { 616, -1 },
6539 { 100, -1 },
6540 { 361, -1 },
6541 { -1, -1 },
6542 { 704, -1 },
6543 { 690, -1 },
6544 { -1, -1 },
6545 { -1, -1 },
6546 { -1, -1 },
6547 { 227, -1 },
6548 { -1, -1 },
6549 { 531, -1 },
6550 { 869, -1 },
6551 { 739, -1 },
6552 { 4, -1 },
6553 { -1, -1 },
6554 { 83, -1 },
6555 { 10, 2049 },
6556 { -1, -1 },
6557 { -1, -1 },
6558 { -1, -1 },
6559 { 202, -1 },
6560 { -1, -1 },
6561 { -1, -1 },
6562 { -1, -1 },
6563 { -1, -1 },
6564 { 528, 2149 },
6565 { -1, -1 },
6566 { -1, -1 },
6567 { -1, -1 },
6568 { 445, -1 },
6569 { 733, -1 },
6570 { -1, -1 },
6571 { -1, -1 },
6572 { 322, -1 },
6573 { 541, -1 },
6574 { -1, -1 },
6575 { -1, -1 },
6576 { 18, 2088 },
6577 { -1, -1 },
6578 { -1, -1 },
6579 { 331, -1 },
6580 { 190, -1 },
6581 { -1, -1 },
6582 { -1, -1 },
6583 { 266, -1 },
6584 { -1, -1 },
6585 { 54, -1 },
6586 { -1, -1 },
6587 { 576, -1 },
6588 { -1, -1 },
6589 { 797, -1 },
6590 { -1, -1 },
6591 { 545, -1 },
6592 { -1, -1 },
6593 { -1, -1 },
6594 { 396, 2086 },
6595 { -1, -1 },
6596 { 35, -1 },
6597 { 51, -1 },
6598 { 801, -1 },
6599 { -1, -1 },
6600 { -1, -1 },
6601 { -1, -1 },
6602 { 454, 2141 },
6603 { 722, 2190 },
6604 { 696, -1 },
6605 { 14, -1 },
6606 { -1, -1 },
6607 { -1, -1 },
6608 { 412, -1 },
6609 { 829, -1 },
6610 { -1, -1 },
6611 { -1, -1 },
6612 { 21, -1 },
6613 { 671, -1 },
6614 { 510, -1 },
6615 { -1, -1 },
6616 { 777, -1 },
6617 { -1, -1 },
6618 { 337, -1 },
6619 { -1, -1 },
6620 { -1, -1 },
6621 { -1, -1 },
6622 { 834, -1 },
6623 { -1, -1 },
6624 { -1, -1 },
6625 { -1, -1 },
6626 { -1, -1 },
6627 { -1, -1 },
6628 { -1, -1 },
6629 { 186, 2188 },
6630 { -1, -1 },
6631 { -1, -1 },
6632 { 65, -1 },
6633 { 213, -1 },
6634 { 94, -1 },
6635 { 444, 2137 },
6636 { -1, -1 },
6637 { 749, -1 },
6638 { -1, -1 },
6639 { -1, -1 },
6640 { -1, -1 },
6641 { -1, -1 },
6642 { -1, -1 },
6643 { 244, -1 },
6644 { -1, -1 },
6645 { 767, -1 },
6646 { 617, -1 },
6647 { -1, -1 },
6648 { -1, -1 },
6649 { -1, -1 },
6650 { 206, -1 },
6651 { -1, -1 },
6652 { -1, -1 },
6653 { 77, -1 },
6654 { 684, -1 },
6655 { -1, -1 },
6656 { -1, -1 },
6657 { 650, -1 },
6658 { 235, 2189 },
6659 { -1, -1 },
6660 { 127, -1 },
6661 { 348, -1 },
6662 { -1, -1 },
6663 { -1, -1 },
6664 { 193, -1 },
6665 { 430, -1 },
6666 { -1, -1 },
6667 { -1, -1 },
6668 { -1, -1 },
6669 { -1, -1 },
6670 { 411, -1 },
6671 { -1, -1 },
6672 { -1, -1 },
6673 { -1, -1 },
6674 { -1, -1 },
6675 { -1, -1 },
6676 { 344, -1 },
6677 { 685, -1 },
6678 { -1, -1 },
6679 { 31, -1 },
6680 { -1, -1 },
6681 { 314, 2104 },
6682 { -1, -1 },
6683 { -1, -1 },
6684 { -1, -1 },
6685 { -1, -1 },
6686 { -1, -1 },
6687 { -1, -1 },
6688 { -1, -1 },
6689 { 619, -1 },
6690 { -1, -1 },
6691 { 194, -1 },
6692 { 775, -1 },
6693 { -1, -1 },
6694 { 636, -1 },
6695 { -1, -1 },
6696 { -1, -1 },
6697 { 270, -1 },
6698 { -1, -1 },
6699 { -1, -1 },
6700 { -1, -1 },
6701 { -1, -1 },
6702 { -1, -1 },
6703 { -1, -1 },
6704 { 546, -1 },
6705 { -1, -1 },
6706 { -1, -1 },
6707 { 157, -1 },
6708 { 561, 2146 },
6709 { 618, 2171 },
6710 { -1, -1 },
6711 { 63, -1 },
6712 { -1, -1 },
6713 { 340, -1 },
6714 { -1, -1 },
6715 { 864, -1 },
6716 { 151, -1 },
6717 { -1, -1 },
6718 { -1, -1 },
6719 { 34, 2114 },
6720 { -1, -1 },
6721 { 654, -1 },
6722 { 98, -1 },
6723 { -1, -1 },
6724 { -1, -1 },
6725 { 770, -1 },
6726 { 223, -1 },
6727 { 702, -1 },
6728 { -1, -1 },
6729 { -1, -1 },
6730 { 714, -1 },
6731 { 437, -1 },
6732 { 538, -1 },
6733 { -1, -1 },
6734 { -1, -1 },
6735 { -1, -1 },
6736 { -1, -1 },
6737 { -1, -1 },
6738 { 419, -1 },
6739 { -1, -1 },
6740 { 286, 2175 },
6741 { -1, -1 },
6742 { -1, -1 },
6743 { -1, -1 },
6744 { -1, -1 },
6745 { -1, -1 },
6746 { -1, -1 },
6747 { 144, -1 },
6748 { 712, -1 },
6749 { 173, -1 },
6750 { -1, -1 },
6751 { -1, -1 },
6752 { 258, -1 },
6753 { -1, -1 },
6754 { -1, -1 },
6755 { -1, -1 },
6756 { 874, -1 },
6757 { -1, -1 },
6758 { -1, -1 },
6759 { -1, -1 },
6760 { -1, -1 },
6761 { -1, -1 },
6762 { -1, -1 },
6763 { -1, -1 },
6764 { -1, -1 },
6765 { -1, -1 },
6766 { 615, -1 },
6767 { 711, 2154 },
6768 { -1, -1 },
6769 { 483, -1 },
6770 { -1, -1 },
6771 { -1, -1 },
6772 { 273, -1 },
6773 { 753, -1 },
6774 { -1, -1 },
6775 { 376, -1 },
6776 { 597, 2138 },
6777 { -1, -1 },
6778 { -1, -1 },
6779 { 81, -1 },
6780 { -1, -1 },
6781 { -1, -1 },
6782 { 380, -1 },
6783 { -1, -1 },
6784 { -1, -1 },
6785 { -1, -1 },
6786 { -1, -1 },
6787 { -1, -1 },
6788 { 82, 2053 },
6789 { -1, -1 },
6790 { 632, -1 },
6791 { -1, -1 },
6792 { -1, -1 },
6793 { -1, -1 },
6794 { -1, -1 },
6795 { -1, -1 },
6796 { 647, -1 },
6797 { -1, -1 },
6798 { -1, -1 },
6799 { 245, 2084 },
6800 { 215, -1 },
6801 { -1, -1 },
6802 { -1, -1 },
6803 { -1, -1 },
6804 { 345, 2183 },
6805 { -1, -1 },
6806 { -1, -1 },
6807 { -1, -1 },
6808 { -1, -1 },
6809 { -1, -1 },
6810 { -1, -1 },
6811 { -1, -1 },
6812 { -1, -1 },
6813 { -1, -1 },
6814 { -1, -1 },
6815 { -1, -1 },
6816 { 533, -1 },
6817 { -1, -1 },
6818 { -1, -1 },
6819 { 815, -1 },
6820 { 808, -1 },
6821 { -1, -1 },
6822 { -1, -1 },
6823 { -1, -1 },
6824 { 552, -1 },
6825 { -1, -1 },
6826 { -1, -1 },
6827 { -1, -1 },
6828 { 569, -1 },
6829 { -1, -1 },
6830 { -1, -1 },
6831 { -1, -1 },
6832 { 428, 2148 },
6833 { -1, -1 },
6834 { -1, -1 },
6835 { -1, -1 },
6836 { -1, -1 },
6837 { -1, -1 },
6838 { -1, -1 },
6839 { -1, -1 },
6840 { -1, -1 },
6841 { -1, -1 },
6842 { -1, -1 },
6843 { -1, -1 },
6844 { -1, -1 },
6845 { 333, -1 },
6846 { -1, -1 },
6847 { -1, -1 },
6848 { -1, -1 },
6849 { -1, -1 },
6850 { -1, -1 },
6851 { 846, -1 },
6852 { 732, -1 },
6853 { -1, -1 },
6854 { 841, -1 },
6855 { -1, -1 },
6856 { 58, -1 },
6857 { -1, -1 },
6858 { 357, -1 },
6859 { 12, -1 },
6860 { -1, -1 },
6861 { -1, -1 },
6862 { -1, -1 },
6863 { -1, -1 },
6864 { -1, -1 },
6865 { -1, -1 },
6866 { -1, -1 },
6867 { -1, -1 },
6868 { -1, -1 },
6869 { 641, -1 },
6870 { -1, -1 },
6871 { -1, -1 },
6872 { 200, -1 },
6873 { -1, -1 },
6874 { -1, -1 },
6875 { -1, -1 },
6876 { -1, -1 },
6877 { -1, -1 },
6878 { -1, -1 },
6879 { 637, 2167 },
6880 { -1, -1 },
6881 { -1, -1 },
6882 { -1, -1 },
6883 { 461, 2118 },
6884 { -1, -1 },
6885 { 802, -1 },
6886 { -1, -1 },
6887 { -1, -1 },
6888 { 803, -1 },
6889 { -1, -1 },
6890 { -1, -1 },
6891 { -1, -1 },
6892 { -1, -1 },
6893 { -1, -1 },
6894 { -1, -1 },
6895 { 216, 2073 },
6896 { -1, -1 },
6897 { -1, -1 },
6898 { -1, -1 },
6899 { -1, -1 },
6900 { 594, -1 },
6901 { -1, -1 },
6902 { 806, -1 },
6903 { -1, -1 },
6904 { -1, -1 },
6905 { 163, -1 },
6906 { -1, -1 },
6907 { 662, -1 },
6908 { 877, -1 },
6909 { -1, -1 },
6910 { 649, -1 },
6911 { -1, -1 },
6912 { -1, -1 },
6913 { -1, -1 },
6914 { -1, -1 },
6915 { -1, -1 },
6916 { -1, -1 },
6917 { -1, -1 },
6918 { -1, -1 },
6919 { -1, -1 },
6920 { -1, -1 },
6921 { -1, -1 },
6922 { 521, -1 },
6923 { 459, 2145 },
6924 { -1, -1 },
6925 { -1, -1 },
6926 { -1, -1 },
6927 { 167, -1 },
6928 { 32, -1 },
6929 { 143, 2078 },
6930 { -1, -1 },
6931 { 113, -1 },
6932 { 455, 2191 },
6933 { -1, -1 },
6934 { 24, -1 },
6935 { -1, -1 },
6936 { 776, -1 },
6937 { -1, -1 },
6938 { -1, -1 },
6939 { 90, -1 },
6940 { -1, -1 },
6941 { 133, -1 },
6942 { -1, -1 },
6943 { -1, -1 },
6944 { 288, -1 },
6945 { -1, -1 },
6946 { -1, -1 },
6947 { 125, 2139 },
6948 { -1, -1 },
6949 { -1, -1 },
6950 { 120, 2166 },
6951 { -1, -1 },
6952 { -1, -1 },
6953 { -1, -1 },
6954 { -1, -1 },
6955 { 201, -1 },
6956 { 162, -1 },
6957 { -1, -1 },
6958 { 639, -1 },
6959 { -1, -1 },
6960 { 371, -1 },
6961 { 598, -1 },
6962 { 721, -1 },
6963 { 301, 2075 },
6964 { -1, -1 },
6965 { -1, -1 },
6966 { 187, -1 },
6967 { 500, -1 },
6968 { -1, -1 },
6969 { 780, -1 },
6970 { 87, 2071 },
6971 { -1, -1 },
6972 { -1, -1 },
6973 { 761, -1 },
6974 { -1, -1 },
6975 { -1, -1 },
6976 { 294, -1 },
6977 { 392, -1 },
6978 { -1, -1 },
6979 { -1, -1 },
6980 { -1, -1 },
6981 { -1, -1 },
6982 { -1, -1 },
6983 { -1, -1 },
6984 { -1, -1 },
6985 { -1, -1 },
6986 { 257, 2096 },
6987 { 842, -1 },
6988 { -1, -1 },
6989 { -1, -1 },
6990 { -1, -1 },
6991 { -1, -1 },
6992 { 22, -1 },
6993 { -1, -1 },
6994 { 397, -1 },
6995 { -1, -1 },
6996 { 60, 2147 },
6997 { -1, -1 },
6998 { 53, 2198 },
6999 { -1, -1 },
7000 { 607, -1 },
7001 { 759, -1 },
7002 { 835, -1 },
7003 { 238, 2161 },
7004 { -1, -1 },
7005 { 652, -1 },
7006 { -1, -1 },
7007 { -1, -1 },
7008 { -1, -1 },
7009 { 848, -1 },
7010 { 730, -1 },
7011 { -1, -1 },
7012 { -1, -1 },
7013 { -1, -1 },
7014 { -1, -1 },
7015 { 416, -1 },
7016 { 45, -1 },
7017 { 78, 2061 },
7018 { 97, -1 },
7019 { 105, -1 },
7020 { 109, -1 },
7021 { 123, -1 },
7022 { 138, 2067 },
7023 { 139, -1 },
7024 { 148, -1 },
7025 { 156, -1 },
7026 { 180, 2105 },
7027 { 181, 2195 },
7028 { 183, -1 },
7029 { 189, -1 },
7030 { 191, -1 },
7031 { 203, -1 },
7032 { 204, -1 },
7033 { 210, -1 },
7034 { 211, 2162 },
7035 { 226, -1 },
7036 { 247, 2134 },
7037 { 249, -1 },
7038 { 250, -1 },
7039 { 276, -1 },
7040 { 281, -1 },
7041 { 289, -1 },
7042 { 300, -1 },
7043 { 316, -1 },
7044 { 336, -1 },
7045 { 356, -1 },
7046 { 373, 2106 },
7047 { 374, -1 },
7048 { 383, 2115 },
7049 { 385, -1 },
7050 { 387, -1 },
7051 { 391, 2113 },
7052 { 398, -1 },
7053 { 402, -1 },
7054 { 406, -1 },
7055 { 407, 2089 },
7056 { 415, -1 },
7057 { 421, -1 },
7058 { 434, -1 },
7059 { 438, -1 },
7060 { 443, -1 },
7061 { 448, -1 },
7062 { 453, -1 },
7063 { 456, -1 },
7064 { 457, 2097 },
7065 { 458, -1 },
7066 { 464, -1 },
7067 { 469, -1 },
7068 { 470, 2153 },
7069 { 475, 2109 },
7070 { 479, -1 },
7071 { 487, -1 },
7072 { 496, -1 },
7073 { 497, -1 },
7074 { 502, -1 },
7075 { 504, -1 },
7076 { 507, -1 },
7077 { 508, -1 },
7078 { 525, -1 },
7079 { 529, -1 },
7080 { 530, -1 },
7081 { 532, -1 },
7082 { 535, -1 },
7083 { 547, 2199 },
7084 { 553, -1 },
7085 { 554, 2160 },
7086 { 556, -1 },
7087 { 558, -1 },
7088 { 559, -1 },
7089 { 562, -1 },
7090 { 563, -1 },
7091 { 565, -1 },
7092 { 586, 2176 },
7093 { 589, -1 },
7094 { 592, -1 },
7095 { 605, -1 },
7096 { 606, -1 },
7097 { 612, -1 },
7098 { 614, -1 },
7099 { 624, -1 },
7100 { 628, -1 },
7101 { 629, -1 },
7102 { 634, -1 },
7103 { 635, 2163 },
7104 { 638, -1 },
7105 { 655, -1 },
7106 { 661, -1 },
7107 { 666, -1 },
7108 { 670, -1 },
7109 { 680, -1 },
7110 { 681, -1 },
7111 { 692, -1 },
7112 { 698, -1 },
7113 { 700, -1 },
7114 { 707, 2184 },
7115 { 708, -1 },
7116 { 715, -1 },
7117 { 718, -1 },
7118 { 729, -1 },
7119 { 731, -1 },
7120 { 734, -1 },
7121 { 735, -1 },
7122 { 740, -1 },
7123 { 741, -1 },
7124 { 742, -1 },
7125 { 743, -1 },
7126 { 744, -1 },
7127 { 747, -1 },
7128 { 750, -1 },
7129 { 756, -1 },
7130 { 765, -1 },
7131 { 766, -1 },
7132 { 769, -1 },
7133 { 771, -1 },
7134 { 772, -1 },
7135 { 778, -1 },
7136 { 782, -1 },
7137 { 784, 2179 },
7138 { 785, -1 },
7139 { 787, -1 },
7140 { 790, -1 },
7141 { 793, -1 },
7142 { 796, -1 },
7143 { 798, -1 },
7144 { 799, -1 },
7145 { 800, -1 },
7146 { 805, -1 },
7147 { 807, -1 },
7148 { 813, -1 },
7149 { 816, -1 },
7150 { 819, -1 },
7151 { 820, 2196 },
7152 { 824, -1 },
7153 { 833, -1 },
7154 { 836, -1 },
7155 { 843, -1 },
7156 { 844, -1 },
7157 { 847, -1 },
7158 { 849, -1 },
7159 { 850, -1 },
7160 { 851, -1 },
7161 { 858, -1 },
7162 { 860, -1 },
7163 { 862, -1 },
7164 { 865, -1 },
7165 { 868, -1 },
7166 { 872, -1 },
7167 { 873, -1 },
7168 { 876, -1 },
7169 { 882, -1 },
7170};
7171
7172
7173static const HashTableValue JSDOMWindowInstanceTableValues[] =
7174{
7175 { "window", JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_window), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7176 { "self", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_self), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_self) } },
7177 { "document", JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_document), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7178 { "name", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_name), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_name) } },
7179 { "location", JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_location), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_location) } },
7180 { "history", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_history), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7181 { "customElements", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_customElements), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7182 { "locationbar", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_locationbar), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_locationbar) } },
7183 { "menubar", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_menubar), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_menubar) } },
7184 { "personalbar", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_personalbar), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_personalbar) } },
7185 { "scrollbars", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_scrollbars), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_scrollbars) } },
7186 { "statusbar", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_statusbar), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_statusbar) } },
7187 { "toolbar", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_toolbar), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_toolbar) } },
7188 { "status", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_status), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_status) } },
7189 { "closed", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_closed), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7190 { "frames", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_frames), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_frames) } },
7191 { "length", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_length), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_length) } },
7192 { "top", JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_top), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7193 { "opener", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_opener), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_opener) } },
7194 { "parent", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_parent), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_parent) } },
7195 { "frameElement", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_frameElement), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7196 { "navigator", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_navigator), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7197 { "applicationCache", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_applicationCache), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7198 { "event", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_event), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_event) } },
7199 { "defaultStatus", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_defaultStatus), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_defaultStatus) } },
7200 { "defaultstatus", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_defaultstatus), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_defaultstatus) } },
7201 { "offscreenBuffering", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_offscreenBuffering), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_offscreenBuffering) } },
7202 { "clientInformation", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_clientInformation), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_clientInformation) } },
7203#if ENABLE(IOS_GESTURE_EVENTS)
7204 { "ongesturechange", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ongesturechange), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_ongesturechange) } },
7205#else
7206 { 0, 0, NoIntrinsic, { 0, 0 } },
7207#endif
7208#if ENABLE(IOS_GESTURE_EVENTS)
7209 { "ongestureend", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ongestureend), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_ongestureend) } },
7210#else
7211 { 0, 0, NoIntrinsic, { 0, 0 } },
7212#endif
7213#if ENABLE(IOS_GESTURE_EVENTS)
7214 { "ongesturestart", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ongesturestart), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_ongesturestart) } },
7215#else
7216 { 0, 0, NoIntrinsic, { 0, 0 } },
7217#endif
7218#if ENABLE(SPEECH_SYNTHESIS)
7219 { "speechSynthesis", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_speechSynthesis), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7220#else
7221 { 0, 0, NoIntrinsic, { 0, 0 } },
7222#endif
7223 { "openDatabase", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_openDatabase), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_openDatabase) } },
7224 { "onabort", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onabort), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onabort) } },
7225 { "onblur", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onblur), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onblur) } },
7226 { "oncanplay", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_oncanplay), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_oncanplay) } },
7227 { "oncanplaythrough", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_oncanplaythrough), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_oncanplaythrough) } },
7228 { "onchange", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onchange), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onchange) } },
7229 { "onclick", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onclick), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onclick) } },
7230 { "onclose", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onclose), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onclose) } },
7231 { "oncontextmenu", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_oncontextmenu), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_oncontextmenu) } },
7232 { "oncuechange", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_oncuechange), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_oncuechange) } },
7233 { "ondblclick", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ondblclick), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_ondblclick) } },
7234 { "ondrag", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ondrag), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_ondrag) } },
7235 { "ondragend", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ondragend), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_ondragend) } },
7236 { "ondragenter", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ondragenter), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_ondragenter) } },
7237 { "ondragleave", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ondragleave), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_ondragleave) } },
7238 { "ondragover", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ondragover), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_ondragover) } },
7239 { "ondragstart", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ondragstart), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_ondragstart) } },
7240 { "ondrop", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ondrop), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_ondrop) } },
7241 { "ondurationchange", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ondurationchange), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_ondurationchange) } },
7242 { "onemptied", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onemptied), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onemptied) } },
7243 { "onended", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onended), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onended) } },
7244 { "onerror", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onerror), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onerror) } },
7245 { "onfocus", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onfocus), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onfocus) } },
7246 { "oninput", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_oninput), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_oninput) } },
7247 { "oninvalid", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_oninvalid), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_oninvalid) } },
7248 { "onkeydown", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onkeydown), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onkeydown) } },
7249 { "onkeypress", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onkeypress), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onkeypress) } },
7250 { "onkeyup", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onkeyup), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onkeyup) } },
7251 { "onload", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onload), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onload) } },
7252 { "onloadeddata", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onloadeddata), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onloadeddata) } },
7253 { "onloadedmetadata", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onloadedmetadata), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onloadedmetadata) } },
7254 { "onloadstart", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onloadstart), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onloadstart) } },
7255 { "onmousedown", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onmousedown), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onmousedown) } },
7256 { "onmouseenter", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onmouseenter), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onmouseenter) } },
7257 { "onmouseleave", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onmouseleave), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onmouseleave) } },
7258 { "onmousemove", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onmousemove), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onmousemove) } },
7259 { "onmouseout", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onmouseout), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onmouseout) } },
7260 { "onmouseover", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onmouseover), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onmouseover) } },
7261 { "onmouseup", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onmouseup), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onmouseup) } },
7262 { "onpause", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onpause), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onpause) } },
7263 { "onplay", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onplay), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onplay) } },
7264 { "onplaying", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onplaying), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onplaying) } },
7265 { "onprogress", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onprogress), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onprogress) } },
7266 { "onratechange", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onratechange), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onratechange) } },
7267 { "onreset", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onreset), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onreset) } },
7268 { "onresize", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onresize), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onresize) } },
7269 { "onscroll", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onscroll), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onscroll) } },
7270 { "onseeked", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onseeked), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onseeked) } },
7271 { "onseeking", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onseeking), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onseeking) } },
7272 { "onselect", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onselect), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onselect) } },
7273 { "onslotchange", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onslotchange), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onslotchange) } },
7274 { "onstalled", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onstalled), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onstalled) } },
7275 { "onsubmit", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onsubmit), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onsubmit) } },
7276 { "onsuspend", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onsuspend), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onsuspend) } },
7277 { "ontimeupdate", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ontimeupdate), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_ontimeupdate) } },
7278 { "ontoggle", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ontoggle), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_ontoggle) } },
7279 { "onvolumechange", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onvolumechange), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onvolumechange) } },
7280 { "onwaiting", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onwaiting), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onwaiting) } },
7281 { "onwebkitanimationend", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onwebkitanimationend), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onwebkitanimationend) } },
7282 { "onwebkitanimationiteration", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onwebkitanimationiteration), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onwebkitanimationiteration) } },
7283 { "onwebkitanimationstart", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onwebkitanimationstart), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onwebkitanimationstart) } },
7284 { "onwebkittransitionend", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onwebkittransitionend), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onwebkittransitionend) } },
7285 { "onwheel", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onwheel), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onwheel) } },
7286 { "onmousewheel", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onmousewheel), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onmousewheel) } },
7287 { "onsearch", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onsearch), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onsearch) } },
7288#if ENABLE(TOUCH_EVENTS)
7289 { "ontouchcancel", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_ontouchcancel), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_ontouchcancel) } },
7290#else
7291 { 0, 0, NoIntrinsic, { 0, 0 } },
7292#endif
7293#if ENABLE(TOUCH_EVENTS)
7294 { "ontouchend", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_ontouchend), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_ontouchend) } },
7295#else
7296 { 0, 0, NoIntrinsic, { 0, 0 } },
7297#endif
7298#if ENABLE(TOUCH_EVENTS)
7299 { "ontouchmove", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_ontouchmove), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_ontouchmove) } },
7300#else
7301 { 0, 0, NoIntrinsic, { 0, 0 } },
7302#endif
7303#if ENABLE(TOUCH_EVENTS)
7304 { "ontouchstart", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_ontouchstart), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_ontouchstart) } },
7305#else
7306 { 0, 0, NoIntrinsic, { 0, 0 } },
7307#endif
7308#if ENABLE(TOUCH_EVENTS)
7309 { "ontouchforcechange", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_ontouchforcechange), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_ontouchforcechange) } },
7310#else
7311 { 0, 0, NoIntrinsic, { 0, 0 } },
7312#endif
7313#if ENABLE(MOUSE_FORCE_EVENTS)
7314 { "onwebkitmouseforcechanged", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onwebkitmouseforcechanged), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onwebkitmouseforcechanged) } },
7315#else
7316 { 0, 0, NoIntrinsic, { 0, 0 } },
7317#endif
7318#if ENABLE(MOUSE_FORCE_EVENTS)
7319 { "onwebkitmouseforcedown", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onwebkitmouseforcedown), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onwebkitmouseforcedown) } },
7320#else
7321 { 0, 0, NoIntrinsic, { 0, 0 } },
7322#endif
7323#if ENABLE(MOUSE_FORCE_EVENTS)
7324 { "onwebkitmouseforcewillbegin", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onwebkitmouseforcewillbegin), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onwebkitmouseforcewillbegin) } },
7325#else
7326 { 0, 0, NoIntrinsic, { 0, 0 } },
7327#endif
7328#if ENABLE(MOUSE_FORCE_EVENTS)
7329 { "onwebkitmouseforceup", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onwebkitmouseforceup), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onwebkitmouseforceup) } },
7330#else
7331 { 0, 0, NoIntrinsic, { 0, 0 } },
7332#endif
7333 { "onanimationstart", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onanimationstart), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onanimationstart) } },
7334 { "onanimationiteration", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onanimationiteration), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onanimationiteration) } },
7335 { "onanimationend", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onanimationend), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onanimationend) } },
7336 { "onanimationcancel", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onanimationcancel), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onanimationcancel) } },
7337 { "ontransitionrun", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ontransitionrun), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_ontransitionrun) } },
7338 { "ontransitionstart", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ontransitionstart), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_ontransitionstart) } },
7339 { "ontransitionend", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ontransitionend), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_ontransitionend) } },
7340 { "ontransitioncancel", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ontransitioncancel), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_ontransitioncancel) } },
7341 { "ongotpointercapture", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ongotpointercapture), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_ongotpointercapture) } },
7342 { "onlostpointercapture", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onlostpointercapture), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onlostpointercapture) } },
7343 { "onpointerdown", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onpointerdown), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onpointerdown) } },
7344 { "onpointermove", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onpointermove), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onpointermove) } },
7345 { "onpointerup", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onpointerup), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onpointerup) } },
7346 { "onpointercancel", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onpointercancel), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onpointercancel) } },
7347 { "onpointerover", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onpointerover), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onpointerover) } },
7348 { "onpointerout", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onpointerout), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onpointerout) } },
7349 { "onpointerenter", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onpointerenter), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onpointerenter) } },
7350 { "onpointerleave", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onpointerleave), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onpointerleave) } },
7351 { "onselectstart", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onselectstart), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onselectstart) } },
7352 { "onselectionchange", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onselectionchange), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onselectionchange) } },
7353 { "screen", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_screen), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_screen) } },
7354 { "innerWidth", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_innerWidth), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_innerWidth) } },
7355 { "innerHeight", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_innerHeight), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_innerHeight) } },
7356 { "scrollX", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_scrollX), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_scrollX) } },
7357 { "pageXOffset", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_pageXOffset), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_pageXOffset) } },
7358 { "scrollY", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_scrollY), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_scrollY) } },
7359 { "pageYOffset", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_pageYOffset), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_pageYOffset) } },
7360 { "screenX", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_screenX), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_screenX) } },
7361 { "screenLeft", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_screenLeft), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_screenLeft) } },
7362 { "screenY", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_screenY), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_screenY) } },
7363 { "screenTop", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_screenTop), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_screenTop) } },
7364 { "outerWidth", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_outerWidth), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_outerWidth) } },
7365 { "outerHeight", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_outerHeight), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_outerHeight) } },
7366 { "devicePixelRatio", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_devicePixelRatio), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_devicePixelRatio) } },
7367 { "styleMedia", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_styleMedia), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7368#if ENABLE(ORIENTATION_EVENTS)
7369 { "orientation", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_orientation), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7370#else
7371 { 0, 0, NoIntrinsic, { 0, 0 } },
7372#endif
7373#if ENABLE(ORIENTATION_EVENTS)
7374 { "onorientationchange", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onorientationchange), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onorientationchange) } },
7375#else
7376 { 0, 0, NoIntrinsic, { 0, 0 } },
7377#endif
7378#if ENABLE(DEVICE_ORIENTATION)
7379 { "ondevicemotion", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ondevicemotion), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_ondevicemotion) } },
7380#else
7381 { 0, 0, NoIntrinsic, { 0, 0 } },
7382#endif
7383#if ENABLE(DEVICE_ORIENTATION)
7384 { "ondeviceorientation", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ondeviceorientation), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_ondeviceorientation) } },
7385#else
7386 { 0, 0, NoIntrinsic, { 0, 0 } },
7387#endif
7388 { "visualViewport", JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_visualViewport), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_visualViewport) } },
7389 { "onafterprint", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onafterprint), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onafterprint) } },
7390 { "onbeforeprint", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onbeforeprint), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onbeforeprint) } },
7391 { "onbeforeunload", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onbeforeunload), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onbeforeunload) } },
7392 { "onhashchange", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onhashchange), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onhashchange) } },
7393 { "onlanguagechange", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onlanguagechange), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onlanguagechange) } },
7394 { "onmessage", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onmessage), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onmessage) } },
7395 { "onoffline", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onoffline), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onoffline) } },
7396 { "ononline", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ononline), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_ononline) } },
7397 { "onpagehide", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onpagehide), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onpagehide) } },
7398 { "onpageshow", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onpageshow), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onpageshow) } },
7399 { "onpopstate", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onpopstate), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onpopstate) } },
7400 { "onrejectionhandled", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onrejectionhandled), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onrejectionhandled) } },
7401 { "onstorage", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onstorage), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onstorage) } },
7402 { "onunhandledrejection", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onunhandledrejection), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onunhandledrejection) } },
7403 { "onunload", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_onunload), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_onunload) } },
7404 { "localStorage", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_localStorage), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7405 { "origin", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_origin), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_origin) } },
7406 { "isSecureContext", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_isSecureContext), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7407 { "caches", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_caches), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_caches) } },
7408 { "indexedDB", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_indexedDB), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7409 { "webkitIndexedDB", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_webkitIndexedDB), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7410 { "crypto", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_crypto), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7411 { "performance", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_performance), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSDOMWindow_performance) } },
7412 { "sessionStorage", JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_sessionStorage), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7413#if ENABLE(TOUCH_EVENTS)
7414 { "Touch", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_TouchConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7415#else
7416 { 0, 0, NoIntrinsic, { 0, 0 } },
7417#endif
7418#if ENABLE(TOUCH_EVENTS)
7419 { "TouchEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_TouchEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7420#else
7421 { 0, 0, NoIntrinsic, { 0, 0 } },
7422#endif
7423#if ENABLE(TOUCH_EVENTS)
7424 { "TouchList", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_TouchListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7425#else
7426 { 0, 0, NoIntrinsic, { 0, 0 } },
7427#endif
7428#if ENABLE(WIRELESS_PLAYBACK_TARGET)
7429 { "WebKitPlaybackTargetAvailabilityEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_WebKitPlaybackTargetAvailabilityEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7430#else
7431 { 0, 0, NoIntrinsic, { 0, 0 } },
7432#endif
7433#if ENABLE(APPLE_PAY)
7434 { "ApplePayError", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ApplePayErrorConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7435#else
7436 { 0, 0, NoIntrinsic, { 0, 0 } },
7437#endif
7438#if ENABLE(APPLE_PAY)
7439 { "ApplePaySession", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_ApplePaySession), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_ApplePaySession) } },
7440#else
7441 { 0, 0, NoIntrinsic, { 0, 0 } },
7442#endif
7443#if ENABLE(APPLE_PAY)
7444 { "ApplePaySetup", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_ApplePaySetup), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_ApplePaySetup) } },
7445#else
7446 { 0, 0, NoIntrinsic, { 0, 0 } },
7447#endif
7448#if ENABLE(APPLE_PAY)
7449 { "ApplePaySetupFeature", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_ApplePaySetupFeature), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_ApplePaySetupFeature) } },
7450#else
7451 { 0, 0, NoIntrinsic, { 0, 0 } },
7452#endif
7453 { "Clipboard", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_Clipboard), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_Clipboard) } },
7454 { "ClipboardItem", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_ClipboardItem), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_ClipboardItem) } },
7455 { "Cache", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_Cache), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_Cache) } },
7456 { "CacheStorage", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_CacheStorage), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_CacheStorage) } },
7457 { "ContactsManager", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_ContactsManager), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_ContactsManager) } },
7458#if ENABLE(WEB_AUTHN)
7459 { "Credential", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_Credential), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_Credential) } },
7460#else
7461 { 0, 0, NoIntrinsic, { 0, 0 } },
7462#endif
7463#if ENABLE(WEB_AUTHN)
7464 { "CredentialsContainer", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_CredentialsContainer), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_CredentialsContainer) } },
7465#else
7466 { 0, 0, NoIntrinsic, { 0, 0 } },
7467#endif
7468#if ENABLE(ENCRYPTED_MEDIA)
7469 { "MediaKeyMessageEvent", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_MediaKeyMessageEvent), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_MediaKeyMessageEvent) } },
7470#else
7471 { 0, 0, NoIntrinsic, { 0, 0 } },
7472#endif
7473#if ENABLE(ENCRYPTED_MEDIA)
7474 { "MediaKeySession", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_MediaKeySession), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_MediaKeySession) } },
7475#else
7476 { 0, 0, NoIntrinsic, { 0, 0 } },
7477#endif
7478#if ENABLE(ENCRYPTED_MEDIA)
7479 { "MediaKeyStatusMap", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_MediaKeyStatusMap), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_MediaKeyStatusMap) } },
7480#else
7481 { 0, 0, NoIntrinsic, { 0, 0 } },
7482#endif
7483#if ENABLE(ENCRYPTED_MEDIA)
7484 { "MediaKeySystemAccess", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_MediaKeySystemAccess), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_MediaKeySystemAccess) } },
7485#else
7486 { 0, 0, NoIntrinsic, { 0, 0 } },
7487#endif
7488#if ENABLE(ENCRYPTED_MEDIA)
7489 { "MediaKeys", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_MediaKeys), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_MediaKeys) } },
7490#else
7491 { 0, 0, NoIntrinsic, { 0, 0 } },
7492#endif
7493#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
7494 { "WebKitMediaKeyMessageEvent", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_WebKitMediaKeyMessageEvent), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_WebKitMediaKeyMessageEvent) } },
7495#else
7496 { 0, 0, NoIntrinsic, { 0, 0 } },
7497#endif
7498#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
7499 { "WebKitMediaKeyNeededEvent", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_WebKitMediaKeyNeededEvent), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_WebKitMediaKeyNeededEvent) } },
7500#else
7501 { 0, 0, NoIntrinsic, { 0, 0 } },
7502#endif
7503#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
7504 { "WebKitMediaKeySession", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_WebKitMediaKeySession), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_WebKitMediaKeySession) } },
7505#else
7506 { 0, 0, NoIntrinsic, { 0, 0 } },
7507#endif
7508#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
7509 { "WebKitMediaKeys", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_WebKitMediaKeys), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_WebKitMediaKeys) } },
7510#else
7511 { 0, 0, NoIntrinsic, { 0, 0 } },
7512#endif
7513 { "FileSystem", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_FileSystem), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_FileSystem) } },
7514 { "FileSystemDirectoryEntry", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_FileSystemDirectoryEntry), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_FileSystemDirectoryEntry) } },
7515 { "FileSystemDirectoryReader", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_FileSystemDirectoryReader), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_FileSystemDirectoryReader) } },
7516 { "FileSystemEntry", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_FileSystemEntry), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_FileSystemEntry) } },
7517 { "FileSystemFileEntry", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_FileSystemFileEntry), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_FileSystemFileEntry) } },
7518 { "Headers", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HeadersConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7519 { "Request", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_RequestConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7520 { "Response", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ResponseConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7521#if ENABLE(GAMEPAD)
7522 { "Gamepad", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_Gamepad), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_Gamepad) } },
7523#else
7524 { 0, 0, NoIntrinsic, { 0, 0 } },
7525#endif
7526#if ENABLE(GAMEPAD)
7527 { "GamepadButton", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_GamepadButton), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_GamepadButton) } },
7528#else
7529 { 0, 0, NoIntrinsic, { 0, 0 } },
7530#endif
7531#if ENABLE(GAMEPAD)
7532 { "GamepadEvent", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_GamepadEvent), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_GamepadEvent) } },
7533#else
7534 { 0, 0, NoIntrinsic, { 0, 0 } },
7535#endif
7536#if ENABLE(GEOLOCATION)
7537 { "Geolocation", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_GeolocationConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7538#else
7539 { 0, 0, NoIntrinsic, { 0, 0 } },
7540#endif
7541#if ENABLE(GEOLOCATION)
7542 { "GeolocationCoordinates", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_GeolocationCoordinatesConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7543#else
7544 { 0, 0, NoIntrinsic, { 0, 0 } },
7545#endif
7546#if ENABLE(GEOLOCATION)
7547 { "GeolocationPosition", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_GeolocationPositionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7548#else
7549 { 0, 0, NoIntrinsic, { 0, 0 } },
7550#endif
7551#if ENABLE(GEOLOCATION)
7552 { "GeolocationPositionError", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_GeolocationPositionErrorConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7553#else
7554 { 0, 0, NoIntrinsic, { 0, 0 } },
7555#endif
7556 { "Highlight", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_Highlight), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_Highlight) } },
7557 { "HighlightRegister", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_HighlightRegister), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_HighlightRegister) } },
7558 { "IDBCursor", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_IDBCursorConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7559 { "IDBCursorWithValue", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_IDBCursorWithValueConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7560 { "IDBDatabase", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_IDBDatabaseConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7561 { "IDBFactory", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_IDBFactoryConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7562 { "IDBIndex", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_IDBIndexConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7563 { "IDBKeyRange", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_IDBKeyRangeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7564 { "IDBObjectStore", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_IDBObjectStoreConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7565 { "IDBOpenDBRequest", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_IDBOpenDBRequestConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7566 { "IDBRequest", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_IDBRequestConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7567 { "IDBTransaction", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_IDBTransactionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7568 { "IDBVersionChangeEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_IDBVersionChangeEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7569 { "MediaCapabilities", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_MediaCapabilities), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_MediaCapabilities) } },
7570#if ENABLE(MEDIA_STREAM)
7571 { "BlobEvent", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_BlobEvent), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_BlobEvent) } },
7572#else
7573 { 0, 0, NoIntrinsic, { 0, 0 } },
7574#endif
7575#if ENABLE(MEDIA_STREAM)
7576 { "MediaRecorder", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_MediaRecorder), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_MediaRecorder) } },
7577#else
7578 { 0, 0, NoIntrinsic, { 0, 0 } },
7579#endif
7580#if ENABLE(MEDIA_STREAM)
7581 { "MediaRecorderErrorEvent", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_MediaRecorderErrorEvent), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_MediaRecorderErrorEvent) } },
7582#else
7583 { 0, 0, NoIntrinsic, { 0, 0 } },
7584#endif
7585#if ENABLE(MEDIA_SESSION)
7586 { "MediaMetadata", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_MediaMetadataConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7587#else
7588 { 0, 0, NoIntrinsic, { 0, 0 } },
7589#endif
7590#if ENABLE(MEDIA_SESSION)
7591 { "MediaSession", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_MediaSessionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7592#else
7593 { 0, 0, NoIntrinsic, { 0, 0 } },
7594#endif
7595#if ENABLE(MEDIA_SESSION_COORDINATOR)
7596 { "MediaSessionCoordinator", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_MediaSessionCoordinator), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_MediaSessionCoordinator) } },
7597#else
7598 { 0, 0, NoIntrinsic, { 0, 0 } },
7599#endif
7600#if ENABLE(MEDIA_SOURCE)
7601 { "MediaSource", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_MediaSource), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_MediaSource) } },
7602#else
7603 { 0, 0, NoIntrinsic, { 0, 0 } },
7604#endif
7605#if ENABLE(MEDIA_SOURCE)
7606 { "SourceBuffer", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_SourceBuffer), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_SourceBuffer) } },
7607#else
7608 { 0, 0, NoIntrinsic, { 0, 0 } },
7609#endif
7610#if ENABLE(MEDIA_SOURCE)
7611 { "SourceBufferList", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_SourceBufferList), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_SourceBufferList) } },
7612#else
7613 { 0, 0, NoIntrinsic, { 0, 0 } },
7614#endif
7615#if ENABLE(MEDIA_STREAM)
7616 { "CanvasCaptureMediaStreamTrack", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CanvasCaptureMediaStreamTrackConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7617#else
7618 { 0, 0, NoIntrinsic, { 0, 0 } },
7619#endif
7620#if ENABLE(MEDIA_STREAM)
7621 { "MediaDeviceInfo", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_MediaDeviceInfoConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7622#else
7623 { 0, 0, NoIntrinsic, { 0, 0 } },
7624#endif
7625#if ENABLE(MEDIA_STREAM)
7626 { "MediaDevices", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_MediaDevices), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_MediaDevices) } },
7627#else
7628 { 0, 0, NoIntrinsic, { 0, 0 } },
7629#endif
7630#if ENABLE(MEDIA_STREAM)
7631 { "MediaStream", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_MediaStreamConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7632#else
7633 { 0, 0, NoIntrinsic, { 0, 0 } },
7634#endif
7635#if ENABLE(MEDIA_STREAM)
7636 { "MediaStreamTrack", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_MediaStreamTrackConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7637#else
7638 { 0, 0, NoIntrinsic, { 0, 0 } },
7639#endif
7640#if ENABLE(MEDIA_STREAM)
7641 { "MediaStreamTrackEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_MediaStreamTrackEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7642#else
7643 { 0, 0, NoIntrinsic, { 0, 0 } },
7644#endif
7645#if ENABLE(MEDIA_STREAM)
7646 { "OverconstrainedError", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_OverconstrainedErrorConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7647#else
7648 { 0, 0, NoIntrinsic, { 0, 0 } },
7649#endif
7650#if ENABLE(MEDIA_STREAM)
7651 { "OverconstrainedErrorEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_OverconstrainedErrorEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7652#else
7653 { 0, 0, NoIntrinsic, { 0, 0 } },
7654#endif
7655#if ENABLE(WEB_RTC)
7656 { "RTCCertificate", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_RTCCertificate), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_RTCCertificate) } },
7657#else
7658 { 0, 0, NoIntrinsic, { 0, 0 } },
7659#endif
7660#if ENABLE(WEB_RTC)
7661 { "RTCDTMFSender", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_RTCDTMFSender), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_RTCDTMFSender) } },
7662#else
7663 { 0, 0, NoIntrinsic, { 0, 0 } },
7664#endif
7665#if ENABLE(WEB_RTC)
7666 { "RTCDTMFToneChangeEvent", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_RTCDTMFToneChangeEvent), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_RTCDTMFToneChangeEvent) } },
7667#else
7668 { 0, 0, NoIntrinsic, { 0, 0 } },
7669#endif
7670#if ENABLE(WEB_RTC)
7671 { "RTCDataChannel", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_RTCDataChannel), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_RTCDataChannel) } },
7672#else
7673 { 0, 0, NoIntrinsic, { 0, 0 } },
7674#endif
7675#if ENABLE(WEB_RTC)
7676 { "RTCDataChannelEvent", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_RTCDataChannelEvent), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_RTCDataChannelEvent) } },
7677#else
7678 { 0, 0, NoIntrinsic, { 0, 0 } },
7679#endif
7680#if ENABLE(WEB_RTC)
7681 { "RTCIceCandidate", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_RTCIceCandidate), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_RTCIceCandidate) } },
7682#else
7683 { 0, 0, NoIntrinsic, { 0, 0 } },
7684#endif
7685#if ENABLE(WEB_RTC)
7686 { "RTCIceTransport", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_RTCIceTransport), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_RTCIceTransport) } },
7687#else
7688 { 0, 0, NoIntrinsic, { 0, 0 } },
7689#endif
7690#if ENABLE(WEB_RTC)
7691 { "RTCPeerConnection", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_RTCPeerConnection), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_RTCPeerConnection) } },
7692#else
7693 { 0, 0, NoIntrinsic, { 0, 0 } },
7694#endif
7695#if ENABLE(WEB_RTC)
7696 { "RTCPeerConnectionIceErrorEvent", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_RTCPeerConnectionIceErrorEvent), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_RTCPeerConnectionIceErrorEvent) } },
7697#else
7698 { 0, 0, NoIntrinsic, { 0, 0 } },
7699#endif
7700#if ENABLE(WEB_RTC)
7701 { "RTCPeerConnectionIceEvent", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_RTCPeerConnectionIceEvent), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_RTCPeerConnectionIceEvent) } },
7702#else
7703 { 0, 0, NoIntrinsic, { 0, 0 } },
7704#endif
7705#if ENABLE(WEB_RTC)
7706 { "RTCRtpReceiver", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_RTCRtpReceiver), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_RTCRtpReceiver) } },
7707#else
7708 { 0, 0, NoIntrinsic, { 0, 0 } },
7709#endif
7710#if ENABLE(WEB_RTC)
7711 { "SFrameTransform", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_SFrameTransform), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_SFrameTransform) } },
7712#else
7713 { 0, 0, NoIntrinsic, { 0, 0 } },
7714#endif
7715#if ENABLE(WEB_RTC)
7716 { "RTCRtpScriptTransform", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_RTCRtpScriptTransform), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_RTCRtpScriptTransform) } },
7717#else
7718 { 0, 0, NoIntrinsic, { 0, 0 } },
7719#endif
7720#if ENABLE(WEB_RTC)
7721 { "RTCRtpSender", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_RTCRtpSender), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_RTCRtpSender) } },
7722#else
7723 { 0, 0, NoIntrinsic, { 0, 0 } },
7724#endif
7725#if ENABLE(WEB_RTC)
7726 { "RTCRtpTransceiver", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_RTCRtpTransceiver), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_RTCRtpTransceiver) } },
7727#else
7728 { 0, 0, NoIntrinsic, { 0, 0 } },
7729#endif
7730#if ENABLE(WEB_RTC)
7731 { "RTCSessionDescription", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_RTCSessionDescription), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_RTCSessionDescription) } },
7732#else
7733 { 0, 0, NoIntrinsic, { 0, 0 } },
7734#endif
7735#if ENABLE(WEB_RTC)
7736 { "RTCStatsReport", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_RTCStatsReport), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_RTCStatsReport) } },
7737#else
7738 { 0, 0, NoIntrinsic, { 0, 0 } },
7739#endif
7740#if ENABLE(WEB_RTC)
7741 { "RTCTrackEvent", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_RTCTrackEvent), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_RTCTrackEvent) } },
7742#else
7743 { 0, 0, NoIntrinsic, { 0, 0 } },
7744#endif
7745#if ENABLE(MODEL_ELEMENT)
7746 { "HTMLModelElement", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_HTMLModelElement), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_HTMLModelElement) } },
7747#else
7748 { 0, 0, NoIntrinsic, { 0, 0 } },
7749#endif
7750#if ENABLE(NOTIFICATIONS)
7751 { "Notification", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_NotificationConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7752#else
7753 { 0, 0, NoIntrinsic, { 0, 0 } },
7754#endif
7755#if ENABLE(PAYMENT_REQUEST)
7756 { "MerchantValidationEvent", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_MerchantValidationEvent), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_MerchantValidationEvent) } },
7757#else
7758 { 0, 0, NoIntrinsic, { 0, 0 } },
7759#endif
7760#if ENABLE(PAYMENT_REQUEST)
7761 { "PaymentAddress", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_PaymentAddress), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_PaymentAddress) } },
7762#else
7763 { 0, 0, NoIntrinsic, { 0, 0 } },
7764#endif
7765#if ENABLE(PAYMENT_REQUEST)
7766 { "PaymentMethodChangeEvent", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_PaymentMethodChangeEvent), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_PaymentMethodChangeEvent) } },
7767#else
7768 { 0, 0, NoIntrinsic, { 0, 0 } },
7769#endif
7770#if ENABLE(PAYMENT_REQUEST)
7771 { "PaymentRequest", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_PaymentRequest), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_PaymentRequest) } },
7772#else
7773 { 0, 0, NoIntrinsic, { 0, 0 } },
7774#endif
7775#if ENABLE(PAYMENT_REQUEST)
7776 { "PaymentRequestUpdateEvent", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_PaymentRequestUpdateEvent), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_PaymentRequestUpdateEvent) } },
7777#else
7778 { 0, 0, NoIntrinsic, { 0, 0 } },
7779#endif
7780#if ENABLE(PAYMENT_REQUEST)
7781 { "PaymentResponse", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_PaymentResponse), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_PaymentResponse) } },
7782#else
7783 { 0, 0, NoIntrinsic, { 0, 0 } },
7784#endif
7785#if ENABLE(PICTURE_IN_PICTURE_API)
7786 { "EnterPictureInPictureEvent", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_EnterPictureInPictureEvent), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_EnterPictureInPictureEvent) } },
7787#else
7788 { 0, 0, NoIntrinsic, { 0, 0 } },
7789#endif
7790#if ENABLE(PICTURE_IN_PICTURE_API)
7791 { "PictureInPictureWindow", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_PictureInPictureWindow), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_PictureInPictureWindow) } },
7792#else
7793 { 0, 0, NoIntrinsic, { 0, 0 } },
7794#endif
7795#if ENABLE(WIRELESS_PLAYBACK_TARGET)
7796 { "RemotePlayback", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_RemotePlayback), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_RemotePlayback) } },
7797#else
7798 { 0, 0, NoIntrinsic, { 0, 0 } },
7799#endif
7800 { "webkitSpeechRecognition", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_webkitSpeechRecognition), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_webkitSpeechRecognition) } },
7801 { "SpeechRecognitionAlternative", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_SpeechRecognitionAlternative), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_SpeechRecognitionAlternative) } },
7802 { "SpeechRecognitionErrorEvent", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_SpeechRecognitionErrorEvent), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_SpeechRecognitionErrorEvent) } },
7803 { "SpeechRecognitionEvent", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_SpeechRecognitionEvent), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_SpeechRecognitionEvent) } },
7804 { "SpeechRecognitionResult", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_SpeechRecognitionResult), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_SpeechRecognitionResult) } },
7805 { "SpeechRecognitionResultList", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_SpeechRecognitionResultList), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_SpeechRecognitionResultList) } },
7806#if ENABLE(SPEECH_SYNTHESIS)
7807 { "SpeechSynthesisEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SpeechSynthesisEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7808#else
7809 { 0, 0, NoIntrinsic, { 0, 0 } },
7810#endif
7811#if ENABLE(SPEECH_SYNTHESIS)
7812 { "SpeechSynthesisUtterance", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SpeechSynthesisUtteranceConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7813#else
7814 { 0, 0, NoIntrinsic, { 0, 0 } },
7815#endif
7816 { "ByteLengthQueuingStrategy", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ByteLengthQueuingStrategyConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7817 { "CountQueuingStrategy", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CountQueuingStrategyConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7818 { "ReadableStream", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ReadableStreamConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7819 { "TransformStream", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_TransformStream), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_TransformStream) } },
7820 { "TransformStreamDefaultController", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_TransformStreamDefaultController), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_TransformStreamDefaultController) } },
7821 { "WritableStream", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_WritableStream), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_WritableStream) } },
7822 { "WritableStreamDefaultController", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_WritableStreamDefaultController), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_WritableStreamDefaultController) } },
7823 { "WritableStreamDefaultWriter", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_WritableStreamDefaultWriter), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_WritableStreamDefaultWriter) } },
7824#if ENABLE(WEB_AUDIO)
7825 { "AnalyserNode", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_AnalyserNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7826#else
7827 { 0, 0, NoIntrinsic, { 0, 0 } },
7828#endif
7829#if ENABLE(WEB_AUDIO)
7830 { "AudioBuffer", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_AudioBufferConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7831#else
7832 { 0, 0, NoIntrinsic, { 0, 0 } },
7833#endif
7834#if ENABLE(WEB_AUDIO)
7835 { "AudioBufferSourceNode", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_AudioBufferSourceNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7836#else
7837 { 0, 0, NoIntrinsic, { 0, 0 } },
7838#endif
7839#if ENABLE(WEB_AUDIO)
7840 { "AudioContext", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_AudioContext), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_AudioContext) } },
7841#else
7842 { 0, 0, NoIntrinsic, { 0, 0 } },
7843#endif
7844#if ENABLE(WEB_AUDIO)
7845 { "AudioDestinationNode", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_AudioDestinationNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7846#else
7847 { 0, 0, NoIntrinsic, { 0, 0 } },
7848#endif
7849#if ENABLE(WEB_AUDIO)
7850 { "AudioListener", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_AudioListenerConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7851#else
7852 { 0, 0, NoIntrinsic, { 0, 0 } },
7853#endif
7854#if ENABLE(WEB_AUDIO)
7855 { "AudioNode", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_AudioNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7856#else
7857 { 0, 0, NoIntrinsic, { 0, 0 } },
7858#endif
7859#if ENABLE(WEB_AUDIO)
7860 { "AudioParam", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_AudioParamConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7861#else
7862 { 0, 0, NoIntrinsic, { 0, 0 } },
7863#endif
7864#if ENABLE(WEB_AUDIO)
7865 { "AudioParamMap", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_AudioParamMap), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_AudioParamMap) } },
7866#else
7867 { 0, 0, NoIntrinsic, { 0, 0 } },
7868#endif
7869#if ENABLE(WEB_AUDIO)
7870 { "AudioProcessingEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_AudioProcessingEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7871#else
7872 { 0, 0, NoIntrinsic, { 0, 0 } },
7873#endif
7874#if ENABLE(WEB_AUDIO)
7875 { "AudioScheduledSourceNode", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_AudioScheduledSourceNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7876#else
7877 { 0, 0, NoIntrinsic, { 0, 0 } },
7878#endif
7879#if ENABLE(WEB_AUDIO)
7880 { "AudioWorklet", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_AudioWorklet), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_AudioWorklet) } },
7881#else
7882 { 0, 0, NoIntrinsic, { 0, 0 } },
7883#endif
7884#if ENABLE(WEB_AUDIO)
7885 { "AudioWorkletNode", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_AudioWorkletNode), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_AudioWorkletNode) } },
7886#else
7887 { 0, 0, NoIntrinsic, { 0, 0 } },
7888#endif
7889#if ENABLE(WEB_AUDIO)
7890 { "BaseAudioContext", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_BaseAudioContext), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_BaseAudioContext) } },
7891#else
7892 { 0, 0, NoIntrinsic, { 0, 0 } },
7893#endif
7894#if ENABLE(WEB_AUDIO)
7895 { "BiquadFilterNode", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_BiquadFilterNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7896#else
7897 { 0, 0, NoIntrinsic, { 0, 0 } },
7898#endif
7899#if ENABLE(WEB_AUDIO)
7900 { "ChannelMergerNode", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ChannelMergerNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7901#else
7902 { 0, 0, NoIntrinsic, { 0, 0 } },
7903#endif
7904#if ENABLE(WEB_AUDIO)
7905 { "ChannelSplitterNode", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ChannelSplitterNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7906#else
7907 { 0, 0, NoIntrinsic, { 0, 0 } },
7908#endif
7909#if ENABLE(WEB_AUDIO)
7910 { "ConstantSourceNode", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_ConstantSourceNode), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_ConstantSourceNode) } },
7911#else
7912 { 0, 0, NoIntrinsic, { 0, 0 } },
7913#endif
7914#if ENABLE(WEB_AUDIO)
7915 { "ConvolverNode", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ConvolverNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7916#else
7917 { 0, 0, NoIntrinsic, { 0, 0 } },
7918#endif
7919#if ENABLE(WEB_AUDIO)
7920 { "DelayNode", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_DelayNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7921#else
7922 { 0, 0, NoIntrinsic, { 0, 0 } },
7923#endif
7924#if ENABLE(WEB_AUDIO)
7925 { "DynamicsCompressorNode", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_DynamicsCompressorNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7926#else
7927 { 0, 0, NoIntrinsic, { 0, 0 } },
7928#endif
7929#if ENABLE(WEB_AUDIO)
7930 { "GainNode", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_GainNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7931#else
7932 { 0, 0, NoIntrinsic, { 0, 0 } },
7933#endif
7934#if ENABLE(WEB_AUDIO)
7935 { "IIRFilterNode", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_IIRFilterNode), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_IIRFilterNode) } },
7936#else
7937 { 0, 0, NoIntrinsic, { 0, 0 } },
7938#endif
7939#if ENABLE(VIDEO) && ENABLE(WEB_AUDIO)
7940 { "MediaElementAudioSourceNode", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_MediaElementAudioSourceNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7941#else
7942 { 0, 0, NoIntrinsic, { 0, 0 } },
7943#endif
7944#if ENABLE(MEDIA_STREAM) && ENABLE(WEB_AUDIO)
7945 { "MediaStreamAudioDestinationNode", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_MediaStreamAudioDestinationNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7946#else
7947 { 0, 0, NoIntrinsic, { 0, 0 } },
7948#endif
7949#if ENABLE(MEDIA_STREAM) && ENABLE(WEB_AUDIO)
7950 { "MediaStreamAudioSourceNode", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_MediaStreamAudioSourceNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7951#else
7952 { 0, 0, NoIntrinsic, { 0, 0 } },
7953#endif
7954#if ENABLE(WEB_AUDIO)
7955 { "OfflineAudioCompletionEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_OfflineAudioCompletionEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7956#else
7957 { 0, 0, NoIntrinsic, { 0, 0 } },
7958#endif
7959#if ENABLE(WEB_AUDIO)
7960 { "OfflineAudioContext", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_OfflineAudioContext), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_OfflineAudioContext) } },
7961#else
7962 { 0, 0, NoIntrinsic, { 0, 0 } },
7963#endif
7964#if ENABLE(WEB_AUDIO)
7965 { "OscillatorNode", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_OscillatorNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7966#else
7967 { 0, 0, NoIntrinsic, { 0, 0 } },
7968#endif
7969#if ENABLE(WEB_AUDIO)
7970 { "PannerNode", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_PannerNode), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_PannerNode) } },
7971#else
7972 { 0, 0, NoIntrinsic, { 0, 0 } },
7973#endif
7974#if ENABLE(WEB_AUDIO)
7975 { "PeriodicWave", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_PeriodicWaveConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7976#else
7977 { 0, 0, NoIntrinsic, { 0, 0 } },
7978#endif
7979#if ENABLE(WEB_AUDIO)
7980 { "ScriptProcessorNode", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ScriptProcessorNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7981#else
7982 { 0, 0, NoIntrinsic, { 0, 0 } },
7983#endif
7984#if ENABLE(WEB_AUDIO)
7985 { "StereoPannerNode", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_StereoPannerNode), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_StereoPannerNode) } },
7986#else
7987 { 0, 0, NoIntrinsic, { 0, 0 } },
7988#endif
7989#if ENABLE(WEB_AUDIO)
7990 { "WaveShaperNode", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_WaveShaperNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
7991#else
7992 { 0, 0, NoIntrinsic, { 0, 0 } },
7993#endif
7994#if ENABLE(WEB_AUTHN)
7995 { "AuthenticatorAssertionResponse", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_AuthenticatorAssertionResponse), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_AuthenticatorAssertionResponse) } },
7996#else
7997 { 0, 0, NoIntrinsic, { 0, 0 } },
7998#endif
7999#if ENABLE(WEB_AUTHN)
8000 { "AuthenticatorAttestationResponse", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_AuthenticatorAttestationResponse), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_AuthenticatorAttestationResponse) } },
8001#else
8002 { 0, 0, NoIntrinsic, { 0, 0 } },
8003#endif
8004#if ENABLE(WEB_AUTHN)
8005 { "AuthenticatorResponse", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_AuthenticatorResponse), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_AuthenticatorResponse) } },
8006#else
8007 { 0, 0, NoIntrinsic, { 0, 0 } },
8008#endif
8009#if ENABLE(WEB_AUTHN)
8010 { "PublicKeyCredential", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_PublicKeyCredential), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_PublicKeyCredential) } },
8011#else
8012 { 0, 0, NoIntrinsic, { 0, 0 } },
8013#endif
8014 { "Database", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_Database), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_Database) } },
8015 { "SQLError", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_SQLError), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_SQLError) } },
8016 { "SQLResultSet", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_SQLResultSet), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_SQLResultSet) } },
8017 { "SQLResultSetRowList", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_SQLResultSetRowList), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_SQLResultSetRowList) } },
8018 { "SQLTransaction", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SQLTransactionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8019#if ENABLE(WEBGPU)
8020 { "GPUBufferUsage", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_GPUBufferUsage), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_GPUBufferUsage) } },
8021#else
8022 { 0, 0, NoIntrinsic, { 0, 0 } },
8023#endif
8024#if ENABLE(WEBGPU)
8025 { "GPUCanvasContext", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_GPUCanvasContext), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_GPUCanvasContext) } },
8026#else
8027 { 0, 0, NoIntrinsic, { 0, 0 } },
8028#endif
8029#if ENABLE(WEBGPU)
8030 { "GPUColorWrite", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_GPUColorWrite), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_GPUColorWrite) } },
8031#else
8032 { 0, 0, NoIntrinsic, { 0, 0 } },
8033#endif
8034#if ENABLE(WEBGPU)
8035 { "GPUOutOfMemoryError", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_GPUOutOfMemoryError), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_GPUOutOfMemoryError) } },
8036#else
8037 { 0, 0, NoIntrinsic, { 0, 0 } },
8038#endif
8039#if ENABLE(WEBGPU)
8040 { "GPUShaderStage", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_GPUShaderStage), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_GPUShaderStage) } },
8041#else
8042 { 0, 0, NoIntrinsic, { 0, 0 } },
8043#endif
8044#if ENABLE(WEBGPU)
8045 { "GPUTextureUsage", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_GPUTextureUsage), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_GPUTextureUsage) } },
8046#else
8047 { 0, 0, NoIntrinsic, { 0, 0 } },
8048#endif
8049#if ENABLE(WEBGPU)
8050 { "GPUUncapturedErrorEvent", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_GPUUncapturedErrorEvent), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_GPUUncapturedErrorEvent) } },
8051#else
8052 { 0, 0, NoIntrinsic, { 0, 0 } },
8053#endif
8054#if ENABLE(WEBGPU)
8055 { "GPUValidationError", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_GPUValidationError), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_GPUValidationError) } },
8056#else
8057 { 0, 0, NoIntrinsic, { 0, 0 } },
8058#endif
8059#if ENABLE(WEBGPU)
8060 { "GPU", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_GPU), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_GPU) } },
8061#else
8062 { 0, 0, NoIntrinsic, { 0, 0 } },
8063#endif
8064#if ENABLE(WEBGPU)
8065 { "GPUAdapter", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_GPUAdapter), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_GPUAdapter) } },
8066#else
8067 { 0, 0, NoIntrinsic, { 0, 0 } },
8068#endif
8069#if ENABLE(WEBGPU)
8070 { "GPUBindGroup", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_GPUBindGroup), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_GPUBindGroup) } },
8071#else
8072 { 0, 0, NoIntrinsic, { 0, 0 } },
8073#endif
8074#if ENABLE(WEBGPU)
8075 { "GPUBindGroupLayout", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_GPUBindGroupLayout), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_GPUBindGroupLayout) } },
8076#else
8077 { 0, 0, NoIntrinsic, { 0, 0 } },
8078#endif
8079#if ENABLE(WEBGPU)
8080 { "GPUBuffer", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_GPUBuffer), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_GPUBuffer) } },
8081#else
8082 { 0, 0, NoIntrinsic, { 0, 0 } },
8083#endif
8084#if ENABLE(WEBGPU)
8085 { "GPUCommandBuffer", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_GPUCommandBuffer), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_GPUCommandBuffer) } },
8086#else
8087 { 0, 0, NoIntrinsic, { 0, 0 } },
8088#endif
8089#if ENABLE(WEBGPU)
8090 { "GPUCommandEncoder", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_GPUCommandEncoder), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_GPUCommandEncoder) } },
8091#else
8092 { 0, 0, NoIntrinsic, { 0, 0 } },
8093#endif
8094#if ENABLE(WEBGPU)
8095 { "GPUComputePassEncoder", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_GPUComputePassEncoder), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_GPUComputePassEncoder) } },
8096#else
8097 { 0, 0, NoIntrinsic, { 0, 0 } },
8098#endif
8099#if ENABLE(WEBGPU)
8100 { "GPUComputePipeline", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_GPUComputePipeline), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_GPUComputePipeline) } },
8101#else
8102 { 0, 0, NoIntrinsic, { 0, 0 } },
8103#endif
8104#if ENABLE(WEBGPU)
8105 { "GPUDevice", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_GPUDevice), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_GPUDevice) } },
8106#else
8107 { 0, 0, NoIntrinsic, { 0, 0 } },
8108#endif
8109#if ENABLE(WEBGPU)
8110 { "GPUPipelineLayout", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_GPUPipelineLayout), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_GPUPipelineLayout) } },
8111#else
8112 { 0, 0, NoIntrinsic, { 0, 0 } },
8113#endif
8114#if ENABLE(WEBGPU)
8115 { "GPUProgrammablePassEncoder", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_GPUProgrammablePassEncoder), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_GPUProgrammablePassEncoder) } },
8116#else
8117 { 0, 0, NoIntrinsic, { 0, 0 } },
8118#endif
8119#if ENABLE(WEBGPU)
8120 { "GPUQueue", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_GPUQueue), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_GPUQueue) } },
8121#else
8122 { 0, 0, NoIntrinsic, { 0, 0 } },
8123#endif
8124#if ENABLE(WEBGPU)
8125 { "GPURenderPassEncoder", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_GPURenderPassEncoder), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_GPURenderPassEncoder) } },
8126#else
8127 { 0, 0, NoIntrinsic, { 0, 0 } },
8128#endif
8129#if ENABLE(WEBGPU)
8130 { "GPURenderPipeline", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_GPURenderPipeline), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_GPURenderPipeline) } },
8131#else
8132 { 0, 0, NoIntrinsic, { 0, 0 } },
8133#endif
8134#if ENABLE(WEBGPU)
8135 { "GPUSampler", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_GPUSampler), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_GPUSampler) } },
8136#else
8137 { 0, 0, NoIntrinsic, { 0, 0 } },
8138#endif
8139#if ENABLE(WEBGPU)
8140 { "GPUShaderModule", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_GPUShaderModule), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_GPUShaderModule) } },
8141#else
8142 { 0, 0, NoIntrinsic, { 0, 0 } },
8143#endif
8144#if ENABLE(WEBGPU)
8145 { "GPUSwapChain", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_GPUSwapChain), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_GPUSwapChain) } },
8146#else
8147 { 0, 0, NoIntrinsic, { 0, 0 } },
8148#endif
8149#if ENABLE(WEBGPU)
8150 { "GPUTexture", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_GPUTexture), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_GPUTexture) } },
8151#else
8152 { 0, 0, NoIntrinsic, { 0, 0 } },
8153#endif
8154#if ENABLE(WEBGPU)
8155 { "GPUTextureView", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_GPUTextureView), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_GPUTextureView) } },
8156#else
8157 { 0, 0, NoIntrinsic, { 0, 0 } },
8158#endif
8159 { "CloseEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CloseEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8160 { "WebSocket", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_WebSocket), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_WebSocket) } },
8161#if ENABLE(WEBXR)
8162 { "XRBoundedReferenceSpace", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_XRBoundedReferenceSpace), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_XRBoundedReferenceSpace) } },
8163#else
8164 { 0, 0, NoIntrinsic, { 0, 0 } },
8165#endif
8166#if ENABLE(WEBXR)
8167 { "XRFrame", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_XRFrame), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_XRFrame) } },
8168#else
8169 { 0, 0, NoIntrinsic, { 0, 0 } },
8170#endif
8171#if ENABLE(WEBXR)
8172 { "XRInputSource", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_XRInputSource), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_XRInputSource) } },
8173#else
8174 { 0, 0, NoIntrinsic, { 0, 0 } },
8175#endif
8176#if ENABLE(WEBXR)
8177 { "XRInputSourceArray", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_XRInputSourceArray), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_XRInputSourceArray) } },
8178#else
8179 { 0, 0, NoIntrinsic, { 0, 0 } },
8180#endif
8181#if ENABLE(WEBXR)
8182 { "XRLayer", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_XRLayer), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_XRLayer) } },
8183#else
8184 { 0, 0, NoIntrinsic, { 0, 0 } },
8185#endif
8186#if ENABLE(WEBXR)
8187 { "XRPose", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_XRPose), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_XRPose) } },
8188#else
8189 { 0, 0, NoIntrinsic, { 0, 0 } },
8190#endif
8191#if ENABLE(WEBXR)
8192 { "XRReferenceSpace", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_XRReferenceSpace), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_XRReferenceSpace) } },
8193#else
8194 { 0, 0, NoIntrinsic, { 0, 0 } },
8195#endif
8196#if ENABLE(WEBXR)
8197 { "XRRenderState", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_XRRenderState), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_XRRenderState) } },
8198#else
8199 { 0, 0, NoIntrinsic, { 0, 0 } },
8200#endif
8201#if ENABLE(WEBXR)
8202 { "XRRigidTransform", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_XRRigidTransform), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_XRRigidTransform) } },
8203#else
8204 { 0, 0, NoIntrinsic, { 0, 0 } },
8205#endif
8206#if ENABLE(WEBXR)
8207 { "XRSession", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_XRSession), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_XRSession) } },
8208#else
8209 { 0, 0, NoIntrinsic, { 0, 0 } },
8210#endif
8211#if ENABLE(WEBXR)
8212 { "XRSpace", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_XRSpace), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_XRSpace) } },
8213#else
8214 { 0, 0, NoIntrinsic, { 0, 0 } },
8215#endif
8216#if ENABLE(WEBXR)
8217 { "XRSystem", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_XRSystem), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_XRSystem) } },
8218#else
8219 { 0, 0, NoIntrinsic, { 0, 0 } },
8220#endif
8221#if ENABLE(WEBXR)
8222 { "XRView", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_XRView), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_XRView) } },
8223#else
8224 { 0, 0, NoIntrinsic, { 0, 0 } },
8225#endif
8226#if ENABLE(WEBXR)
8227 { "XRViewerPose", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_XRViewerPose), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_XRViewerPose) } },
8228#else
8229 { 0, 0, NoIntrinsic, { 0, 0 } },
8230#endif
8231#if ENABLE(WEBXR)
8232 { "XRViewport", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_XRViewport), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_XRViewport) } },
8233#else
8234 { 0, 0, NoIntrinsic, { 0, 0 } },
8235#endif
8236#if ENABLE(WEBXR)
8237 { "XRWebGLLayer", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_XRWebGLLayer), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_XRWebGLLayer) } },
8238#else
8239 { 0, 0, NoIntrinsic, { 0, 0 } },
8240#endif
8241#if ENABLE(WEBXR)
8242 { "XRInputSourceEvent", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_XRInputSourceEvent), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_XRInputSourceEvent) } },
8243#else
8244 { 0, 0, NoIntrinsic, { 0, 0 } },
8245#endif
8246#if ENABLE(WEBXR)
8247 { "XRInputSourcesChangeEvent", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_XRInputSourcesChangeEvent), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_XRInputSourcesChangeEvent) } },
8248#else
8249 { 0, 0, NoIntrinsic, { 0, 0 } },
8250#endif
8251#if ENABLE(WEBXR)
8252 { "XRReferenceSpaceEvent", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_XRReferenceSpaceEvent), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_XRReferenceSpaceEvent) } },
8253#else
8254 { 0, 0, NoIntrinsic, { 0, 0 } },
8255#endif
8256#if ENABLE(WEBXR)
8257 { "XRSessionEvent", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_XRSessionEvent), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_XRSessionEvent) } },
8258#else
8259 { 0, 0, NoIntrinsic, { 0, 0 } },
8260#endif
8261 { "AnimationEffect", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_AnimationEffectConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8262 { "AnimationPlaybackEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_AnimationPlaybackEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8263 { "AnimationTimeline", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_AnimationTimelineConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8264 { "CSSAnimation", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CSSAnimationConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8265 { "CSSTransition", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CSSTransitionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8266 { "DocumentTimeline", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_DocumentTimelineConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8267 { "KeyframeEffect", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_KeyframeEffectConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8268 { "Animation", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_AnimationConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8269#if ENABLE(WEB_CRYPTO)
8270 { "CryptoKey", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CryptoKeyConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8271#else
8272 { 0, 0, NoIntrinsic, { 0, 0 } },
8273#endif
8274#if ENABLE(WEB_CRYPTO)
8275 { "SubtleCrypto", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SubtleCryptoConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8276#else
8277 { 0, 0, NoIntrinsic, { 0, 0 } },
8278#endif
8279 { "CSSConditionRule", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CSSConditionRuleConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8280 { "CSSCounterStyleRule", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_CSSCounterStyleRule), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_CSSCounterStyleRule) } },
8281 { "CSSFontFaceRule", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CSSFontFaceRuleConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8282 { "CSSGroupingRule", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CSSGroupingRuleConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8283 { "CSSImportRule", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CSSImportRuleConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8284 { "CSSKeyframeRule", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CSSKeyframeRuleConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8285 { "CSSKeyframesRule", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CSSKeyframesRuleConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8286 { "CSSMediaRule", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CSSMediaRuleConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8287 { "CSSNamespaceRule", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CSSNamespaceRuleConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8288 { "CSSPageRule", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CSSPageRuleConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8289 { "CSSRule", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CSSRuleConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8290 { "CSSRuleList", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CSSRuleListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8291 { "CSSStyleDeclaration", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CSSStyleDeclarationConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8292 { "CSSStyleRule", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CSSStyleRuleConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8293 { "CSSStyleSheet", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CSSStyleSheetConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8294 { "CSSSupportsRule", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CSSSupportsRuleConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8295 { "CSS", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CSSConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8296 { "DOMMatrix", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_DOMMatrixConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8297 { "WebKitCSSMatrix", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_WebKitCSSMatrixConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8298 { "DOMMatrixReadOnly", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_DOMMatrixReadOnlyConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8299 { "Counter", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CounterConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8300 { "CSSPrimitiveValue", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CSSPrimitiveValueConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8301 { "RGBColor", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_RGBColorConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8302 { "Rect", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_RectConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8303 { "CSSValue", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CSSValueConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8304 { "CSSValueList", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CSSValueListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8305 { "FontFace", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_FontFaceConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8306 { "FontFaceSet", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_FontFaceSetConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8307 { "MediaList", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_MediaListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8308 { "MediaQueryList", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_MediaQueryListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8309 { "MediaQueryListEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_MediaQueryListEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8310 { "StyleSheet", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_StyleSheetConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8311 { "StyleSheetList", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_StyleSheetListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8312#if ENABLE(CSS_TYPED_OM)
8313 { "StylePropertyMap", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_StylePropertyMap), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_StylePropertyMap) } },
8314#else
8315 { 0, 0, NoIntrinsic, { 0, 0 } },
8316#endif
8317#if ENABLE(CSS_TYPED_OM)
8318 { "StylePropertyMapReadOnly", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_StylePropertyMapReadOnly), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_StylePropertyMapReadOnly) } },
8319#else
8320 { 0, 0, NoIntrinsic, { 0, 0 } },
8321#endif
8322#if ENABLE(CSS_TYPED_OM)
8323 { "CSSImageValue", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_CSSImageValue), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_CSSImageValue) } },
8324#else
8325 { 0, 0, NoIntrinsic, { 0, 0 } },
8326#endif
8327#if ENABLE(CSS_TYPED_OM)
8328 { "CSSNumericValue", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_CSSNumericValue), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_CSSNumericValue) } },
8329#else
8330 { 0, 0, NoIntrinsic, { 0, 0 } },
8331#endif
8332#if ENABLE(CSS_TYPED_OM)
8333 { "CSSStyleValue", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_CSSStyleValue), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_CSSStyleValue) } },
8334#else
8335 { 0, 0, NoIntrinsic, { 0, 0 } },
8336#endif
8337#if ENABLE(CSS_TYPED_OM)
8338 { "CSSUnitValue", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_CSSUnitValue), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_CSSUnitValue) } },
8339#else
8340 { 0, 0, NoIntrinsic, { 0, 0 } },
8341#endif
8342#if ENABLE(CSS_TYPED_OM)
8343 { "CSSUnparsedValue", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_CSSUnparsedValue), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_CSSUnparsedValue) } },
8344#else
8345 { 0, 0, NoIntrinsic, { 0, 0 } },
8346#endif
8347 { "AbortController", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_AbortControllerConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8348 { "AbortSignal", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_AbortSignalConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8349 { "AbstractRange", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_AbstractRangeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8350 { "AnimationEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_AnimationEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8351 { "Attr", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_AttrConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8352 { "BeforeLoadEvent", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_BeforeLoadEvent), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_BeforeLoadEvent) } },
8353 { "BeforeUnloadEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_BeforeUnloadEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8354 { "CDATASection", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CDATASectionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8355 { "CharacterData", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CharacterDataConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8356 { "ClipboardEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ClipboardEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8357 { "Comment", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CommentConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8358 { "CompositionEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CompositionEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8359 { "CustomElementRegistry", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CustomElementRegistryConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8360 { "CustomEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CustomEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8361 { "DOMException", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_DOMExceptionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8362 { "DOMImplementation", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_DOMImplementationConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8363 { "DOMPoint", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_DOMPointConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8364 { "DOMPointReadOnly", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_DOMPointReadOnlyConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8365 { "DOMQuad", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_DOMQuadConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8366 { "DOMRect", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_DOMRectConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8367 { "DOMRectList", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_DOMRectListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8368 { "DOMRectReadOnly", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_DOMRectReadOnlyConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8369 { "DOMStringList", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_DOMStringListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8370 { "DOMStringMap", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_DOMStringMapConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8371 { "DataTransfer", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_DataTransferConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8372 { "DataTransferItem", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_DataTransferItem), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_DataTransferItem) } },
8373 { "DataTransferItemList", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_DataTransferItemList), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_DataTransferItemList) } },
8374#if ENABLE(DEVICE_ORIENTATION)
8375 { "DeviceMotionEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_DeviceMotionEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8376#else
8377 { 0, 0, NoIntrinsic, { 0, 0 } },
8378#endif
8379#if ENABLE(DEVICE_ORIENTATION)
8380 { "DeviceOrientationEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_DeviceOrientationEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8381#else
8382 { 0, 0, NoIntrinsic, { 0, 0 } },
8383#endif
8384 { "Document", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_DocumentConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8385 { "DocumentFragment", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_DocumentFragmentConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8386 { "DocumentType", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_DocumentTypeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8387 { "DragEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_DragEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8388 { "Element", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8389 { "ErrorEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ErrorEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8390 { "Event", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_EventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8391 { "EventTarget", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_EventTargetConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8392 { "FocusEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_FocusEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8393 { "HashChangeEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HashChangeEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8394 { "IdleDeadline", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_IdleDeadline), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_IdleDeadline) } },
8395 { "InputEvent", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_InputEvent), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_InputEvent) } },
8396 { "KeyboardEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_KeyboardEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8397#if ENABLE(CHANNEL_MESSAGING)
8398 { "MessageChannel", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_MessageChannelConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8399#else
8400 { 0, 0, NoIntrinsic, { 0, 0 } },
8401#endif
8402 { "MessageEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_MessageEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8403 { "MessagePort", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_MessagePortConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8404 { "MouseEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_MouseEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8405 { "MutationEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_MutationEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8406 { "MutationObserver", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_MutationObserverConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8407 { "WebKitMutationObserver", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_WebKitMutationObserverConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8408 { "MutationRecord", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_MutationRecordConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8409 { "NamedNodeMap", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_NamedNodeMapConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8410 { "Node", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_NodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8411 { "NodeFilter", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_NodeFilterConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8412 { "NodeIterator", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_NodeIteratorConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8413 { "NodeList", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_NodeListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8414 { "OverflowEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_OverflowEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8415 { "PageTransitionEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_PageTransitionEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8416 { "PointerEvent", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_PointerEvent), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_PointerEvent) } },
8417 { "PopStateEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_PopStateEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8418 { "ProcessingInstruction", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ProcessingInstructionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8419 { "ProgressEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ProgressEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8420 { "PromiseRejectionEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_PromiseRejectionEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8421 { "Range", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_RangeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8422 { "SecurityPolicyViolationEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SecurityPolicyViolationEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8423 { "ShadowRoot", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ShadowRootConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8424 { "StaticRange", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_StaticRangeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8425 { "Text", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_TextConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8426 { "TextDecoder", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_TextDecoderConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8427 { "TextDecoderStream", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_TextDecoderStream), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_TextDecoderStream) } },
8428 { "TextEncoder", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_TextEncoderConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8429 { "TextEncoderStream", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_TextEncoderStream), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_TextEncoderStream) } },
8430 { "TextEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_TextEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8431 { "TransitionEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_TransitionEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8432 { "TreeWalker", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_TreeWalkerConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8433 { "UIEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_UIEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8434 { "WebKitAnimationEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_WebKitAnimationEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8435 { "WebKitTransitionEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_WebKitTransitionEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8436 { "WheelEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_WheelEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8437 { "XMLDocument", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_XMLDocumentConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8438 { "SVGDocument", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGDocumentConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8439 { "Blob", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_BlobConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8440 { "File", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_FileConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8441 { "FileList", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_FileListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8442 { "FileReader", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_FileReaderConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8443 { "FormData", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_FormDataConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8444 { "DOMTokenList", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_DOMTokenListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8445 { "URL", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_URLConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8446 { "webkitURL", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_webkitURLConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8447 { "HTMLAllCollection", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLAllCollectionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8448 { "HTMLAnchorElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLAnchorElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8449 { "HTMLAreaElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLAreaElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8450#if ENABLE(ATTACHMENT_ELEMENT)
8451 { "HTMLAttachmentElement", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_HTMLAttachmentElement), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_HTMLAttachmentElement) } },
8452#else
8453 { 0, 0, NoIntrinsic, { 0, 0 } },
8454#endif
8455#if ENABLE(VIDEO)
8456 { "HTMLAudioElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLAudioElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8457#else
8458 { 0, 0, NoIntrinsic, { 0, 0 } },
8459#endif
8460#if ENABLE(VIDEO)
8461 { "Audio", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_AudioConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8462#else
8463 { 0, 0, NoIntrinsic, { 0, 0 } },
8464#endif
8465 { "HTMLBRElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLBRElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8466 { "HTMLBaseElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLBaseElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8467 { "HTMLBodyElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLBodyElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8468 { "HTMLButtonElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLButtonElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8469 { "HTMLCanvasElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLCanvasElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8470 { "HTMLCollection", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLCollectionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8471 { "HTMLDListElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLDListElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8472 { "HTMLDataElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLDataElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8473#if ENABLE(DATALIST_ELEMENT)
8474 { "HTMLDataListElement", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_HTMLDataListElement), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_HTMLDataListElement) } },
8475#else
8476 { 0, 0, NoIntrinsic, { 0, 0 } },
8477#endif
8478 { "HTMLDetailsElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLDetailsElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8479 { "HTMLDialogElement", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_HTMLDialogElement), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_HTMLDialogElement) } },
8480 { "HTMLDirectoryElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLDirectoryElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8481 { "HTMLDivElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLDivElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8482 { "HTMLDocument", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLDocumentConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8483 { "HTMLElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8484 { "HTMLEmbedElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLEmbedElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8485 { "HTMLFieldSetElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLFieldSetElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8486 { "HTMLFontElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLFontElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8487 { "HTMLFormControlsCollection", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLFormControlsCollectionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8488 { "HTMLFormElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLFormElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8489 { "HTMLFrameElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLFrameElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8490 { "HTMLFrameSetElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLFrameSetElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8491 { "HTMLHRElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLHRElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8492 { "HTMLHeadElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLHeadElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8493 { "HTMLHeadingElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLHeadingElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8494 { "HTMLHtmlElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLHtmlElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8495 { "HTMLIFrameElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLIFrameElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8496 { "HTMLImageElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLImageElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8497 { "Image", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ImageConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8498 { "HTMLInputElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLInputElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8499 { "HTMLKeygenElement", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_HTMLKeygenElement), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_HTMLKeygenElement) } },
8500 { "HTMLLIElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLLIElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8501 { "HTMLLabelElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLLabelElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8502 { "HTMLLegendElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLLegendElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8503 { "HTMLLinkElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLLinkElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8504 { "HTMLMapElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLMapElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8505 { "HTMLMarqueeElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLMarqueeElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8506#if ENABLE(VIDEO)
8507 { "HTMLMediaElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLMediaElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8508#else
8509 { 0, 0, NoIntrinsic, { 0, 0 } },
8510#endif
8511 { "HTMLMenuElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLMenuElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8512 { "HTMLMenuItemElement", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_HTMLMenuItemElement), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_HTMLMenuItemElement) } },
8513 { "HTMLMetaElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLMetaElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8514 { "HTMLMeterElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLMeterElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8515 { "HTMLModElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLModElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8516 { "HTMLOListElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLOListElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8517 { "HTMLObjectElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLObjectElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8518 { "HTMLOptGroupElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLOptGroupElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8519 { "HTMLOptionElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLOptionElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8520 { "Option", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_OptionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8521 { "HTMLOptionsCollection", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLOptionsCollectionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8522 { "HTMLOutputElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLOutputElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8523 { "HTMLParagraphElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLParagraphElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8524 { "HTMLParamElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLParamElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8525 { "HTMLPictureElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLPictureElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8526 { "HTMLPreElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLPreElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8527 { "HTMLProgressElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLProgressElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8528 { "HTMLQuoteElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLQuoteElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8529 { "HTMLScriptElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLScriptElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8530 { "HTMLSelectElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLSelectElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8531 { "HTMLSlotElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLSlotElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8532 { "HTMLSourceElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLSourceElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8533 { "HTMLSpanElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLSpanElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8534 { "HTMLStyleElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLStyleElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8535 { "HTMLTableCaptionElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLTableCaptionElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8536 { "HTMLTableCellElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLTableCellElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8537 { "HTMLTableColElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLTableColElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8538 { "HTMLTableElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLTableElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8539 { "HTMLTableRowElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLTableRowElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8540 { "HTMLTableSectionElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLTableSectionElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8541 { "HTMLTemplateElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLTemplateElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8542 { "HTMLTextAreaElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLTextAreaElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8543 { "HTMLTimeElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLTimeElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8544 { "HTMLTitleElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLTitleElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8545#if ENABLE(VIDEO)
8546 { "HTMLTrackElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLTrackElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8547#else
8548 { 0, 0, NoIntrinsic, { 0, 0 } },
8549#endif
8550 { "HTMLUListElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLUListElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8551 { "HTMLUnknownElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLUnknownElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8552#if ENABLE(VIDEO)
8553 { "HTMLVideoElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HTMLVideoElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8554#else
8555 { 0, 0, NoIntrinsic, { 0, 0 } },
8556#endif
8557 { "ImageBitmap", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_ImageBitmap), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_ImageBitmap) } },
8558 { "ImageData", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ImageDataConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8559#if ENABLE(VIDEO)
8560 { "MediaController", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_MediaControllerConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8561#else
8562 { 0, 0, NoIntrinsic, { 0, 0 } },
8563#endif
8564#if ENABLE(ENCRYPTED_MEDIA)
8565 { "MediaEncryptedEvent", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_MediaEncryptedEvent), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_MediaEncryptedEvent) } },
8566#else
8567 { 0, 0, NoIntrinsic, { 0, 0 } },
8568#endif
8569#if ENABLE(VIDEO)
8570 { "MediaError", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_MediaErrorConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8571#else
8572 { 0, 0, NoIntrinsic, { 0, 0 } },
8573#endif
8574#if ENABLE(OFFSCREEN_CANVAS)
8575 { "OffscreenCanvas", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_OffscreenCanvas), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_OffscreenCanvas) } },
8576#else
8577 { 0, 0, NoIntrinsic, { 0, 0 } },
8578#endif
8579 { "RadioNodeList", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_RadioNodeListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8580 { "TextMetrics", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_TextMetricsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8581#if ENABLE(VIDEO)
8582 { "TimeRanges", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_TimeRangesConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8583#else
8584 { 0, 0, NoIntrinsic, { 0, 0 } },
8585#endif
8586 { "URLSearchParams", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_URLSearchParamsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8587 { "ValidityState", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ValidityStateConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8588#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
8589 { "WebKitMediaKeyError", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_WebKitMediaKeyError), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_WebKitMediaKeyError) } },
8590#else
8591 { 0, 0, NoIntrinsic, { 0, 0 } },
8592#endif
8593 { "CanvasGradient", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CanvasGradientConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8594 { "CanvasPattern", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CanvasPatternConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8595 { "CanvasRenderingContext2D", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CanvasRenderingContext2DConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8596 { "ImageBitmapRenderingContext", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_ImageBitmapRenderingContext), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_ImageBitmapRenderingContext) } },
8597#if ENABLE(OFFSCREEN_CANVAS)
8598 { "OffscreenCanvasRenderingContext2D", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_OffscreenCanvasRenderingContext2D), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_OffscreenCanvasRenderingContext2D) } },
8599#else
8600 { 0, 0, NoIntrinsic, { 0, 0 } },
8601#endif
8602 { "Path2D", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_Path2DConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8603#if ENABLE(WEBGL2)
8604 { "WebGL2RenderingContext", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_WebGL2RenderingContext), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_WebGL2RenderingContext) } },
8605#else
8606 { 0, 0, NoIntrinsic, { 0, 0 } },
8607#endif
8608#if ENABLE(WEBGL)
8609 { "WebGLActiveInfo", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_WebGLActiveInfoConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8610#else
8611 { 0, 0, NoIntrinsic, { 0, 0 } },
8612#endif
8613#if ENABLE(WEBGL)
8614 { "WebGLBuffer", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_WebGLBufferConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8615#else
8616 { 0, 0, NoIntrinsic, { 0, 0 } },
8617#endif
8618#if ENABLE(WEBGL)
8619 { "WebGLContextEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_WebGLContextEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8620#else
8621 { 0, 0, NoIntrinsic, { 0, 0 } },
8622#endif
8623#if ENABLE(WEBGL)
8624 { "WebGLFramebuffer", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_WebGLFramebufferConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8625#else
8626 { 0, 0, NoIntrinsic, { 0, 0 } },
8627#endif
8628#if ENABLE(WEBGL)
8629 { "WebGLProgram", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_WebGLProgramConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8630#else
8631 { 0, 0, NoIntrinsic, { 0, 0 } },
8632#endif
8633#if ENABLE(WEBGL)
8634 { "WebGLQuery", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_WebGLQueryConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8635#else
8636 { 0, 0, NoIntrinsic, { 0, 0 } },
8637#endif
8638#if ENABLE(WEBGL)
8639 { "WebGLRenderbuffer", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_WebGLRenderbufferConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8640#else
8641 { 0, 0, NoIntrinsic, { 0, 0 } },
8642#endif
8643#if ENABLE(WEBGL)
8644 { "WebGLRenderingContext", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_WebGLRenderingContextConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8645#else
8646 { 0, 0, NoIntrinsic, { 0, 0 } },
8647#endif
8648#if ENABLE(WEBGL)
8649 { "WebGLSampler", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_WebGLSamplerConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8650#else
8651 { 0, 0, NoIntrinsic, { 0, 0 } },
8652#endif
8653#if ENABLE(WEBGL)
8654 { "WebGLShader", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_WebGLShaderConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8655#else
8656 { 0, 0, NoIntrinsic, { 0, 0 } },
8657#endif
8658#if ENABLE(WEBGL)
8659 { "WebGLShaderPrecisionFormat", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_WebGLShaderPrecisionFormatConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8660#else
8661 { 0, 0, NoIntrinsic, { 0, 0 } },
8662#endif
8663#if ENABLE(WEBGL)
8664 { "WebGLSync", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_WebGLSyncConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8665#else
8666 { 0, 0, NoIntrinsic, { 0, 0 } },
8667#endif
8668#if ENABLE(WEBGL)
8669 { "WebGLTexture", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_WebGLTextureConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8670#else
8671 { 0, 0, NoIntrinsic, { 0, 0 } },
8672#endif
8673#if ENABLE(WEBGL2)
8674 { "WebGLTransformFeedback", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_WebGLTransformFeedback), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_WebGLTransformFeedback) } },
8675#else
8676 { 0, 0, NoIntrinsic, { 0, 0 } },
8677#endif
8678#if ENABLE(WEBGL)
8679 { "WebGLUniformLocation", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_WebGLUniformLocationConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8680#else
8681 { 0, 0, NoIntrinsic, { 0, 0 } },
8682#endif
8683#if ENABLE(WEBGL2)
8684 { "WebGLVertexArrayObject", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_WebGLVertexArrayObject), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_WebGLVertexArrayObject) } },
8685#else
8686 { 0, 0, NoIntrinsic, { 0, 0 } },
8687#endif
8688#if ENABLE(VIDEO)
8689 { "AudioTrack", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_AudioTrackConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8690#else
8691 { 0, 0, NoIntrinsic, { 0, 0 } },
8692#endif
8693#if ENABLE(VIDEO)
8694 { "AudioTrackList", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_AudioTrackListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8695#else
8696 { 0, 0, NoIntrinsic, { 0, 0 } },
8697#endif
8698#if ENABLE(VIDEO)
8699 { "DataCue", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_DataCueConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8700#else
8701 { 0, 0, NoIntrinsic, { 0, 0 } },
8702#endif
8703#if ENABLE(VIDEO)
8704 { "TextTrack", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_TextTrackConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8705#else
8706 { 0, 0, NoIntrinsic, { 0, 0 } },
8707#endif
8708#if ENABLE(VIDEO)
8709 { "TextTrackCue", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_TextTrackCueConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8710#else
8711 { 0, 0, NoIntrinsic, { 0, 0 } },
8712#endif
8713#if ENABLE(VIDEO)
8714 { "TextTrackCueList", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_TextTrackCueListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8715#else
8716 { 0, 0, NoIntrinsic, { 0, 0 } },
8717#endif
8718#if ENABLE(VIDEO)
8719 { "TextTrackList", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_TextTrackListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8720#else
8721 { 0, 0, NoIntrinsic, { 0, 0 } },
8722#endif
8723#if ENABLE(VIDEO)
8724 { "TrackEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_TrackEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8725#else
8726 { 0, 0, NoIntrinsic, { 0, 0 } },
8727#endif
8728#if ENABLE(VIDEO)
8729 { "VTTCue", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_VTTCueConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8730#else
8731 { 0, 0, NoIntrinsic, { 0, 0 } },
8732#endif
8733#if ENABLE(VIDEO)
8734 { "VTTRegion", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_VTTRegionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8735#else
8736 { 0, 0, NoIntrinsic, { 0, 0 } },
8737#endif
8738#if ENABLE(VIDEO)
8739 { "VideoTrack", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_VideoTrackConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8740#else
8741 { 0, 0, NoIntrinsic, { 0, 0 } },
8742#endif
8743#if ENABLE(VIDEO)
8744 { "VideoTrackList", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_VideoTrackListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8745#else
8746 { 0, 0, NoIntrinsic, { 0, 0 } },
8747#endif
8748 { "ApplicationCache", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ApplicationCacheConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8749#if ENABLE(MATHML)
8750 { "MathMLElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_MathMLElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8751#else
8752 { 0, 0, NoIntrinsic, { 0, 0 } },
8753#endif
8754#if ENABLE(MATHML)
8755 { "MathMLMathElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_MathMLMathElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8756#else
8757 { 0, 0, NoIntrinsic, { 0, 0 } },
8758#endif
8759 { "BarProp", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_BarPropConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8760 { "Crypto", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_CryptoConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8761 { "Selection", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SelectionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8762 { "Window", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_WindowConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8763 { "EventSource", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_EventSourceConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8764 { "History", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_HistoryConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8765#if ENABLE(INTERSECTION_OBSERVER)
8766 { "IntersectionObserver", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_IntersectionObserver), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_IntersectionObserver) } },
8767#else
8768 { 0, 0, NoIntrinsic, { 0, 0 } },
8769#endif
8770#if ENABLE(INTERSECTION_OBSERVER)
8771 { "IntersectionObserverEntry", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_IntersectionObserverEntry), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_IntersectionObserverEntry) } },
8772#else
8773 { 0, 0, NoIntrinsic, { 0, 0 } },
8774#endif
8775 { "Location", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_LocationConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8776 { "Navigator", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_NavigatorConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8777 { "Performance", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_PerformanceConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8778 { "PerformanceEntry", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_PerformanceEntryConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8779 { "PerformanceMark", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_PerformanceMarkConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8780 { "PerformanceMeasure", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_PerformanceMeasureConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8781 { "PerformanceNavigation", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_PerformanceNavigationConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8782 { "PerformanceNavigationTiming", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_PerformanceNavigationTiming), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_PerformanceNavigationTiming) } },
8783 { "PerformanceObserver", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_PerformanceObserverConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8784 { "PerformanceObserverEntryList", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_PerformanceObserverEntryListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8785 { "PerformancePaintTiming", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_PerformancePaintTiming), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_PerformancePaintTiming) } },
8786 { "PerformanceResourceTiming", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_PerformanceResourceTimingConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8787 { "PerformanceServerTiming", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_PerformanceServerTiming), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_PerformanceServerTiming) } },
8788 { "PerformanceTiming", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_PerformanceTimingConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8789#if ENABLE(RESIZE_OBSERVER)
8790 { "ResizeObserver", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_ResizeObserver), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_ResizeObserver) } },
8791#else
8792 { 0, 0, NoIntrinsic, { 0, 0 } },
8793#endif
8794#if ENABLE(RESIZE_OBSERVER)
8795 { "ResizeObserverEntry", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_ResizeObserverEntry), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_ResizeObserverEntry) } },
8796#else
8797 { 0, 0, NoIntrinsic, { 0, 0 } },
8798#endif
8799 { "Screen", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_ScreenConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8800 { "UndoItem", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_UndoItem), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_UndoItem) } },
8801 { "UndoManager", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_UndoManager), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_UndoManager) } },
8802#if ENABLE(USER_MESSAGE_HANDLERS)
8803 { "UserMessageHandler", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_UserMessageHandlerConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8804#else
8805 { 0, 0, NoIntrinsic, { 0, 0 } },
8806#endif
8807#if ENABLE(USER_MESSAGE_HANDLERS)
8808 { "UserMessageHandlersNamespace", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_UserMessageHandlersNamespaceConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8809#else
8810 { 0, 0, NoIntrinsic, { 0, 0 } },
8811#endif
8812 { "VisualViewport", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_VisualViewport), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_VisualViewport) } },
8813#if ENABLE(USER_MESSAGE_HANDLERS)
8814 { "WebKitNamespace", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_WebKitNamespaceConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8815#else
8816 { 0, 0, NoIntrinsic, { 0, 0 } },
8817#endif
8818 { "WebKitPoint", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_WebKitPointConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8819 { "MimeType", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_MimeTypeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8820 { "MimeTypeArray", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_MimeTypeArrayConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8821 { "Plugin", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_PluginConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8822 { "PluginArray", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_PluginArrayConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8823 { "Storage", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_StorageConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8824 { "StorageEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_StorageEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8825 { "SVGAElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGAElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8826 { "SVGAltGlyphDefElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGAltGlyphDefElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8827 { "SVGAltGlyphElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGAltGlyphElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8828 { "SVGAltGlyphItemElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGAltGlyphItemElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8829 { "SVGAngle", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGAngleConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8830 { "SVGAnimateColorElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGAnimateColorElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8831 { "SVGAnimateElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGAnimateElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8832 { "SVGAnimateMotionElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGAnimateMotionElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8833 { "SVGAnimateTransformElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGAnimateTransformElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8834 { "SVGAnimatedAngle", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGAnimatedAngleConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8835 { "SVGAnimatedBoolean", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGAnimatedBooleanConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8836 { "SVGAnimatedEnumeration", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGAnimatedEnumerationConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8837 { "SVGAnimatedInteger", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGAnimatedIntegerConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8838 { "SVGAnimatedLength", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGAnimatedLengthConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8839 { "SVGAnimatedLengthList", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGAnimatedLengthListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8840 { "SVGAnimatedNumber", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGAnimatedNumberConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8841 { "SVGAnimatedNumberList", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGAnimatedNumberListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8842 { "SVGAnimatedPreserveAspectRatio", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGAnimatedPreserveAspectRatioConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8843 { "SVGAnimatedRect", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGAnimatedRectConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8844 { "SVGAnimatedString", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGAnimatedStringConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8845 { "SVGAnimatedTransformList", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGAnimatedTransformListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8846 { "SVGAnimationElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGAnimationElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8847 { "SVGCircleElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGCircleElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8848 { "SVGClipPathElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGClipPathElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8849 { "SVGComponentTransferFunctionElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGComponentTransferFunctionElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8850 { "SVGCursorElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGCursorElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8851 { "SVGDefsElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGDefsElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8852 { "SVGDescElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGDescElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8853 { "SVGElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8854 { "SVGEllipseElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGEllipseElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8855 { "SVGFEBlendElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGFEBlendElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8856 { "SVGFEColorMatrixElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGFEColorMatrixElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8857 { "SVGFEComponentTransferElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGFEComponentTransferElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8858 { "SVGFECompositeElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGFECompositeElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8859 { "SVGFEConvolveMatrixElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGFEConvolveMatrixElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8860 { "SVGFEDiffuseLightingElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGFEDiffuseLightingElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8861 { "SVGFEDisplacementMapElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGFEDisplacementMapElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8862 { "SVGFEDistantLightElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGFEDistantLightElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8863 { "SVGFEDropShadowElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGFEDropShadowElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8864 { "SVGFEFloodElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGFEFloodElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8865 { "SVGFEFuncAElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGFEFuncAElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8866 { "SVGFEFuncBElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGFEFuncBElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8867 { "SVGFEFuncGElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGFEFuncGElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8868 { "SVGFEFuncRElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGFEFuncRElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8869 { "SVGFEGaussianBlurElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGFEGaussianBlurElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8870 { "SVGFEImageElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGFEImageElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8871 { "SVGFEMergeElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGFEMergeElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8872 { "SVGFEMergeNodeElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGFEMergeNodeElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8873 { "SVGFEMorphologyElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGFEMorphologyElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8874 { "SVGFEOffsetElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGFEOffsetElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8875 { "SVGFEPointLightElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGFEPointLightElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8876 { "SVGFESpecularLightingElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGFESpecularLightingElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8877 { "SVGFESpotLightElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGFESpotLightElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8878 { "SVGFETileElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGFETileElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8879 { "SVGFETurbulenceElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGFETurbulenceElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8880 { "SVGFilterElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGFilterElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8881 { "SVGFontElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGFontElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8882 { "SVGFontFaceElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGFontFaceElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8883 { "SVGFontFaceFormatElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGFontFaceFormatElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8884 { "SVGFontFaceNameElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGFontFaceNameElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8885 { "SVGFontFaceSrcElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGFontFaceSrcElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8886 { "SVGFontFaceUriElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGFontFaceUriElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8887 { "SVGForeignObjectElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGForeignObjectElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8888 { "SVGGElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGGElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8889 { "SVGGeometryElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGGeometryElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8890 { "SVGGlyphElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGGlyphElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8891 { "SVGGlyphRefElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGGlyphRefElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8892 { "SVGGradientElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGGradientElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8893 { "SVGGraphicsElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGGraphicsElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8894 { "SVGHKernElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGHKernElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8895 { "SVGImageElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGImageElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8896 { "SVGLength", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGLengthConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8897 { "SVGLengthList", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGLengthListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8898 { "SVGLineElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGLineElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8899 { "SVGLinearGradientElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGLinearGradientElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8900 { "SVGMPathElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGMPathElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8901 { "SVGMarkerElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGMarkerElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8902 { "SVGMaskElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGMaskElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8903 { "SVGMatrix", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGMatrixConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8904 { "SVGMetadataElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGMetadataElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8905 { "SVGMissingGlyphElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGMissingGlyphElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8906 { "SVGNumber", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGNumberConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8907 { "SVGNumberList", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGNumberListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8908 { "SVGPathElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGPathElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8909 { "SVGPathSeg", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGPathSegConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8910 { "SVGPathSegArcAbs", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGPathSegArcAbsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8911 { "SVGPathSegArcRel", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGPathSegArcRelConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8912 { "SVGPathSegClosePath", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGPathSegClosePathConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8913 { "SVGPathSegCurvetoCubicAbs", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGPathSegCurvetoCubicAbsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8914 { "SVGPathSegCurvetoCubicRel", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGPathSegCurvetoCubicRelConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8915 { "SVGPathSegCurvetoCubicSmoothAbs", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGPathSegCurvetoCubicSmoothAbsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8916 { "SVGPathSegCurvetoCubicSmoothRel", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGPathSegCurvetoCubicSmoothRelConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8917 { "SVGPathSegCurvetoQuadraticAbs", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGPathSegCurvetoQuadraticAbsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8918 { "SVGPathSegCurvetoQuadraticRel", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGPathSegCurvetoQuadraticRelConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8919 { "SVGPathSegCurvetoQuadraticSmoothAbs", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGPathSegCurvetoQuadraticSmoothAbsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8920 { "SVGPathSegCurvetoQuadraticSmoothRel", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGPathSegCurvetoQuadraticSmoothRelConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8921 { "SVGPathSegLinetoAbs", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGPathSegLinetoAbsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8922 { "SVGPathSegLinetoHorizontalAbs", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGPathSegLinetoHorizontalAbsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8923 { "SVGPathSegLinetoHorizontalRel", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGPathSegLinetoHorizontalRelConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8924 { "SVGPathSegLinetoRel", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGPathSegLinetoRelConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8925 { "SVGPathSegLinetoVerticalAbs", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGPathSegLinetoVerticalAbsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8926 { "SVGPathSegLinetoVerticalRel", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGPathSegLinetoVerticalRelConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8927 { "SVGPathSegList", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGPathSegListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8928 { "SVGPathSegMovetoAbs", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGPathSegMovetoAbsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8929 { "SVGPathSegMovetoRel", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGPathSegMovetoRelConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8930 { "SVGPatternElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGPatternElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8931 { "SVGPoint", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGPointConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8932 { "SVGPointList", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGPointListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8933 { "SVGPolygonElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGPolygonElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8934 { "SVGPolylineElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGPolylineElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8935 { "SVGPreserveAspectRatio", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGPreserveAspectRatioConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8936 { "SVGRadialGradientElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGRadialGradientElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8937 { "SVGRect", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGRectConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8938 { "SVGRectElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGRectElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8939 { "SVGRenderingIntent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGRenderingIntentConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8940 { "SVGSVGElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGSVGElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8941 { "SVGScriptElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGScriptElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8942 { "SVGSetElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGSetElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8943 { "SVGStopElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGStopElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8944 { "SVGStringList", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGStringListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8945 { "SVGStyleElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGStyleElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8946 { "SVGSwitchElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGSwitchElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8947 { "SVGSymbolElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGSymbolElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8948 { "SVGTRefElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGTRefElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8949 { "SVGTSpanElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGTSpanElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8950 { "SVGTextContentElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGTextContentElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8951 { "SVGTextElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGTextElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8952 { "SVGTextPathElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGTextPathElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8953 { "SVGTextPositioningElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGTextPositioningElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8954 { "SVGTitleElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGTitleElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8955 { "SVGTransform", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGTransformConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8956 { "SVGTransformList", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGTransformListConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8957 { "SVGUnitTypes", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGUnitTypesConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8958 { "SVGUseElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGUseElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8959 { "SVGVKernElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGVKernElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8960 { "SVGViewElement", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGViewElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8961 { "SVGViewSpec", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGViewSpecConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8962 { "SVGZoomEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_SVGZoomEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8963 { "Worker", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_WorkerConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8964#if ENABLE(SERVICE_WORKER)
8965 { "ServiceWorker", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_ServiceWorker), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_ServiceWorker) } },
8966#else
8967 { 0, 0, NoIntrinsic, { 0, 0 } },
8968#endif
8969#if ENABLE(SERVICE_WORKER)
8970 { "ServiceWorkerContainer", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_ServiceWorkerContainer), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_ServiceWorkerContainer) } },
8971#else
8972 { 0, 0, NoIntrinsic, { 0, 0 } },
8973#endif
8974#if ENABLE(SERVICE_WORKER)
8975 { "ServiceWorkerRegistration", JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::PropertyCallback, NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_ServiceWorkerRegistration), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_ServiceWorkerRegistration) } },
8976#else
8977 { 0, 0, NoIntrinsic, { 0, 0 } },
8978#endif
8979 { "Worklet", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_WorkletConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8980 { "DOMParser", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_DOMParserConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8981 { "XMLHttpRequest", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_XMLHttpRequestConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8982 { "XMLHttpRequestEventTarget", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_XMLHttpRequestEventTargetConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8983 { "XMLHttpRequestProgressEvent", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_XMLHttpRequestProgressEventConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8984 { "XMLHttpRequestUpload", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_XMLHttpRequestUploadConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8985 { "XMLSerializer", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_XMLSerializerConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8986 { "XPathEvaluator", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_XPathEvaluatorConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8987 { "XPathExpression", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_XPathExpressionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8988 { "XPathResult", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_XPathResultConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8989#if ENABLE(XSLT)
8990 { "XSLTProcessor", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsDOMWindow_XSLTProcessorConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(nullptr) } },
8991#else
8992 { 0, 0, NoIntrinsic, { 0, 0 } },
8993#endif
8994 { "close", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_close), (intptr_t) (0) } },
8995 { "stop", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_stop), (intptr_t) (0) } },
8996 { "focus", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_focus), (intptr_t) (0) } },
8997 { "blur", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_blur), (intptr_t) (0) } },
8998 { "open", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_open), (intptr_t) (0) } },
8999 { "alert", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_alert), (intptr_t) (0) } },
9000 { "confirm", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_confirm), (intptr_t) (0) } },
9001 { "prompt", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_prompt), (intptr_t) (0) } },
9002 { "print", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_print), (intptr_t) (0) } },
9003 { "postMessage", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_postMessage), (intptr_t) (1) } },
9004 { "captureEvents", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_captureEvents), (intptr_t) (0) } },
9005 { "releaseEvents", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_releaseEvents), (intptr_t) (0) } },
9006 { "find", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_find), (intptr_t) (0) } },
9007 { "webkitRequestAnimationFrame", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_webkitRequestAnimationFrame), (intptr_t) (1) } },
9008 { "webkitCancelAnimationFrame", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_webkitCancelAnimationFrame), (intptr_t) (1) } },
9009 { "webkitCancelRequestAnimationFrame", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_webkitCancelRequestAnimationFrame), (intptr_t) (1) } },
9010 { "showModalDialog", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_showModalDialog), (intptr_t) (1) } },
9011 { "getMatchedCSSRules", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_getMatchedCSSRules), (intptr_t) (0) } },
9012 { "webkitConvertPointFromPageToNode", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_webkitConvertPointFromPageToNode), (intptr_t) (0) } },
9013 { "webkitConvertPointFromNodeToPage", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_webkitConvertPointFromNodeToPage), (intptr_t) (0) } },
9014 { "collectMatchingElementsInFlatTree", static_cast<unsigned>(JSC::PropertyAttribute::PropertyCallback), NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_collectMatchingElementsInFlatTree), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_collectMatchingElementsInFlatTree) } },
9015 { "matchingElementInFlatTree", static_cast<unsigned>(JSC::PropertyAttribute::PropertyCallback), NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_matchingElementInFlatTree), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_matchingElementInFlatTree) } },
9016 { "requestAnimationFrame", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_requestAnimationFrame), (intptr_t) (1) } },
9017 { "cancelAnimationFrame", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_cancelAnimationFrame), (intptr_t) (1) } },
9018 { "getComputedStyle", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_getComputedStyle), (intptr_t) (1) } },
9019 { "matchMedia", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_matchMedia), (intptr_t) (1) } },
9020 { "moveTo", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_moveTo), (intptr_t) (0) } },
9021 { "moveBy", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_moveBy), (intptr_t) (0) } },
9022 { "resizeTo", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_resizeTo), (intptr_t) (0) } },
9023 { "resizeBy", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_resizeBy), (intptr_t) (0) } },
9024 { "scroll", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_scroll), (intptr_t) (0) } },
9025 { "scrollTo", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_scrollTo), (intptr_t) (0) } },
9026 { "scrollBy", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_scrollBy), (intptr_t) (0) } },
9027 { "requestIdleCallback", static_cast<unsigned>(JSC::PropertyAttribute::PropertyCallback), NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_requestIdleCallback), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_requestIdleCallback) } },
9028 { "cancelIdleCallback", static_cast<unsigned>(JSC::PropertyAttribute::PropertyCallback), NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_cancelIdleCallback), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_cancelIdleCallback) } },
9029 { "getSelection", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_getSelection), (intptr_t) (0) } },
9030 { "atob", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_atob), (intptr_t) (1) } },
9031 { "btoa", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_btoa), (intptr_t) (1) } },
9032 { "setTimeout", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_setTimeout), (intptr_t) (1) } },
9033 { "clearTimeout", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_clearTimeout), (intptr_t) (0) } },
9034 { "setInterval", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_setInterval), (intptr_t) (1) } },
9035 { "clearInterval", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_clearInterval), (intptr_t) (0) } },
9036 { "queueMicrotask", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_queueMicrotask), (intptr_t) (1) } },
9037 { "createImageBitmap", static_cast<unsigned>(JSC::PropertyAttribute::PropertyCallback), NoIntrinsic, { (intptr_t)static_cast<LazyPropertyCallback>(createJSDOMWindowInstance_createImageBitmap), (intptr_t) static_cast<IsLazyPropertyEnabledCallback>(isEnabledJSDOMWindowInstance_createImageBitmap) } },
9038 { "fetch", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsDOMWindowInstanceFunction_fetch), (intptr_t) (1) } },
9039};
9040
9041static const HashTable JSDOMWindowInstanceTable = { 884, 2047, true, JSDOMWindow::info(), JSDOMWindowInstanceTableValues, JSDOMWindowInstanceTableIndex };
9042const ClassInfo JSDOMWindow::s_info = { "Window", &Base::s_info, &JSDOMWindowInstanceTable, nullptr, CREATE_METHOD_TABLE(JSDOMWindow) };
9043
9044JSDOMWindow::JSDOMWindow(VM& vm, Structure* structure, Ref<DOMWindow>&& impl, JSWindowProxy* proxy)
9045 : JSDOMWindowBase(vm, structure, WTFMove(impl), proxy)
9046{
9047}
9048
9049void JSDOMWindow::finishCreation(VM& vm, JSWindowProxy* proxy)
9050{
9051 Base::finishCreation(vm, proxy);
9052
9053 static_assert(!std::is_base_of<ActiveDOMObject, DOMWindow>::value, "Interface is not marked as [ActiveDOMObject] even though implementation class subclasses ActiveDOMObject.");
9054
9055#if ENABLE(MEDIA_STREAM)
9056 putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().MediaStreamPrivateName(), CustomGetterSetter::create(vm, jsDOMWindow_MediaStreamConstructor, nullptr), static_cast<unsigned>(JSC::PropertyAttribute::CustomValue));
9057#endif
9058#if ENABLE(MEDIA_STREAM)
9059 putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().MediaStreamTrackPrivateName(), CustomGetterSetter::create(vm, jsDOMWindow_MediaStreamTrackConstructor, nullptr), static_cast<unsigned>(JSC::PropertyAttribute::CustomValue));
9060#endif
9061#if ENABLE(WEB_RTC)
9062 if (jsCast<JSDOMGlobalObject*>(globalObject())->scriptExecutionContext()->settingsValues().peerConnectionEnabled)
9063 putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().RTCSessionDescriptionPrivateName(), CustomGetterSetter::create(vm, jsDOMWindow_RTCSessionDescriptionConstructor, nullptr), static_cast<unsigned>(JSC::PropertyAttribute::CustomValue));
9064#endif
9065 putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().ReadableByteStreamControllerPrivateName(), CustomGetterSetter::create(vm, jsDOMWindow_ReadableByteStreamControllerConstructor, nullptr), static_cast<unsigned>(JSC::PropertyAttribute::CustomValue));
9066 putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().ReadableStreamPrivateName(), CustomGetterSetter::create(vm, jsDOMWindow_ReadableStreamConstructor, nullptr), static_cast<unsigned>(JSC::PropertyAttribute::CustomValue));
9067 putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().ReadableStreamBYOBReaderPrivateName(), CustomGetterSetter::create(vm, jsDOMWindow_ReadableStreamBYOBReaderConstructor, nullptr), static_cast<unsigned>(JSC::PropertyAttribute::CustomValue));
9068 putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().ReadableStreamBYOBRequestPrivateName(), CustomGetterSetter::create(vm, jsDOMWindow_ReadableStreamBYOBRequestConstructor, nullptr), static_cast<unsigned>(JSC::PropertyAttribute::CustomValue));
9069 putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().ReadableStreamDefaultControllerPrivateName(), CustomGetterSetter::create(vm, jsDOMWindow_ReadableStreamDefaultControllerConstructor, nullptr), static_cast<unsigned>(JSC::PropertyAttribute::CustomValue));
9070 putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().ReadableStreamDefaultReaderPrivateName(), CustomGetterSetter::create(vm, jsDOMWindow_ReadableStreamDefaultReaderConstructor, nullptr), static_cast<unsigned>(JSC::PropertyAttribute::CustomValue));
9071 if (RuntimeEnabledFeatures::sharedFeatures().transformStreamAPIEnabled())
9072 putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().TransformStreamPrivateName(), CustomGetterSetter::create(vm, jsDOMWindow_TransformStreamConstructor, nullptr), static_cast<unsigned>(JSC::PropertyAttribute::CustomValue));
9073 if (RuntimeEnabledFeatures::sharedFeatures().transformStreamAPIEnabled())
9074 putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().TransformStreamDefaultControllerPrivateName(), CustomGetterSetter::create(vm, jsDOMWindow_TransformStreamDefaultControllerConstructor, nullptr), static_cast<unsigned>(JSC::PropertyAttribute::CustomValue));
9075 if (RuntimeEnabledFeatures::sharedFeatures().writableStreamAPIEnabled())
9076 putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().WritableStreamPrivateName(), CustomGetterSetter::create(vm, jsDOMWindow_WritableStreamConstructor, nullptr), static_cast<unsigned>(JSC::PropertyAttribute::CustomValue));
9077 if (RuntimeEnabledFeatures::sharedFeatures().writableStreamAPIEnabled())
9078 putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().WritableStreamDefaultControllerPrivateName(), CustomGetterSetter::create(vm, jsDOMWindow_WritableStreamDefaultControllerConstructor, nullptr), static_cast<unsigned>(JSC::PropertyAttribute::CustomValue));
9079 if (RuntimeEnabledFeatures::sharedFeatures().writableStreamAPIEnabled())
9080 putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().WritableStreamDefaultWriterPrivateName(), CustomGetterSetter::create(vm, jsDOMWindow_WritableStreamDefaultWriterConstructor, nullptr), static_cast<unsigned>(JSC::PropertyAttribute::CustomValue));
9081 putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().AbortSignalPrivateName(), CustomGetterSetter::create(vm, jsDOMWindow_AbortSignalConstructor, nullptr), static_cast<unsigned>(JSC::PropertyAttribute::CustomValue));
9082 if (RuntimeEnabledFeatures::sharedFeatures().transformStreamAPIEnabled())
9083 putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().TextDecoderStreamDecoderPrivateName(), CustomGetterSetter::create(vm, jsDOMWindow_TextDecoderStreamDecoderConstructor, nullptr), static_cast<unsigned>(JSC::PropertyAttribute::CustomValue));
9084 if (RuntimeEnabledFeatures::sharedFeatures().transformStreamAPIEnabled())
9085 putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().TextEncoderStreamEncoderPrivateName(), CustomGetterSetter::create(vm, jsDOMWindow_TextEncoderStreamEncoderConstructor, nullptr), static_cast<unsigned>(JSC::PropertyAttribute::CustomValue));
9086}
9087
9088JSValue JSDOMWindow::getConstructor(VM& vm, const JSGlobalObject* globalObject)
9089{
9090 return getDOMConstructor<JSDOMWindowDOMConstructor, DOMConstructorID::DOMWindow>(vm, *jsCast<const JSDOMGlobalObject*>(globalObject));
9091}
9092
9093JSC_DEFINE_CUSTOM_GETTER(jsDOMWindowConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
9094{
9095 VM& vm = JSC::getVM(lexicalGlobalObject);
9096 auto throwScope = DECLARE_THROW_SCOPE(vm);
9097 auto* prototype = jsDynamicCast<JSDOMWindowPrototype*>(vm, JSValue::decode(thisValue));
9098 if (UNLIKELY(!prototype))
9099 return throwVMTypeError(lexicalGlobalObject, throwScope);
9100 return JSValue::encode(JSDOMWindow::getConstructor(JSC::getVM(lexicalGlobalObject), prototype->globalObject()));
9101}
9102
9103static inline JSValue jsDOMWindow_windowGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
9104{
9105 UNUSED_PARAM(lexicalGlobalObject);
9106 return thisObject.window(lexicalGlobalObject);
9107}
9108
9109JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_window, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
9110{
9111 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_windowGetter>(*lexicalGlobalObject, thisValue, attributeName);
9112}
9113
9114static inline JSValue jsDOMWindow_selfGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
9115{
9116 UNUSED_PARAM(lexicalGlobalObject);
9117 return thisObject.self(lexicalGlobalObject);
9118}
9119
9120JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_self, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
9121{
9122 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_selfGetter>(*lexicalGlobalObject, thisValue, attributeName);
9123}
9124
9125static inline bool setJSDOMWindow_selfSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
9126{
9127 auto& vm = JSC::getVM(&lexicalGlobalObject);
9128 auto throwScope = DECLARE_THROW_SCOPE(vm);
9129 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9130 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9131 if (!shouldAllowAccess)
9132 return false;
9133 // Shadowing a built-in property.
9134 return replaceStaticPropertySlot(vm, &thisObject, Identifier::fromString(vm, reinterpret_cast<const LChar*>("self"), strlen("self")), value);
9135}
9136
9137JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_self, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
9138{
9139 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_selfSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
9140}
9141
9142static inline JSValue jsDOMWindow_documentGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
9143{
9144 auto& vm = JSC::getVM(&lexicalGlobalObject);
9145 auto throwScope = DECLARE_THROW_SCOPE(vm);
9146 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9147 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9148 if (!shouldAllowAccess)
9149 return jsUndefined();
9150 auto& impl = thisObject.wrapped();
9151 RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<Document>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.document())));
9152}
9153
9154JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_document, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
9155{
9156 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_documentGetter>(*lexicalGlobalObject, thisValue, attributeName);
9157}
9158
9159static inline JSValue jsDOMWindow_nameGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
9160{
9161 auto& vm = JSC::getVM(&lexicalGlobalObject);
9162 auto throwScope = DECLARE_THROW_SCOPE(vm);
9163 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9164 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9165 if (!shouldAllowAccess)
9166 return jsUndefined();
9167 auto& impl = thisObject.wrapped();
9168 RELEASE_AND_RETURN(throwScope, (toJS<IDLDOMString>(lexicalGlobalObject, throwScope, impl.name())));
9169}
9170
9171JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_name, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
9172{
9173 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_nameGetter>(*lexicalGlobalObject, thisValue, attributeName);
9174}
9175
9176static inline bool setJSDOMWindow_nameSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
9177{
9178 auto& vm = JSC::getVM(&lexicalGlobalObject);
9179 auto throwScope = DECLARE_THROW_SCOPE(vm);
9180 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9181 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9182 if (!shouldAllowAccess)
9183 return false;
9184 auto& impl = thisObject.wrapped();
9185 auto nativeValue = convert<IDLDOMString>(lexicalGlobalObject, value);
9186 RETURN_IF_EXCEPTION(throwScope, false);
9187 invokeFunctorPropagatingExceptionIfNecessary(lexicalGlobalObject, throwScope, [&] {
9188 return impl.setName(WTFMove(nativeValue));
9189 });
9190 return true;
9191}
9192
9193JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_name, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
9194{
9195 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_nameSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
9196}
9197
9198static inline JSValue jsDOMWindow_locationGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
9199{
9200 auto& vm = JSC::getVM(&lexicalGlobalObject);
9201 auto throwScope = DECLARE_THROW_SCOPE(vm);
9202 auto& impl = thisObject.wrapped();
9203 RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<Location>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.location())));
9204}
9205
9206JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_location, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
9207{
9208 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_locationGetter>(*lexicalGlobalObject, thisValue, attributeName);
9209}
9210
9211static inline bool setJSDOMWindow_locationSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
9212{
9213 auto& vm = JSC::getVM(&lexicalGlobalObject);
9214 auto throwScope = DECLARE_THROW_SCOPE(vm);
9215 auto id = Identifier::fromString(vm, reinterpret_cast<const LChar*>("location"), strlen("location"));
9216 auto valueToForwardTo = thisObject.get(&lexicalGlobalObject, id);
9217 RETURN_IF_EXCEPTION(throwScope, false);
9218 if (UNLIKELY(!valueToForwardTo.isObject())) {
9219 throwTypeError(&lexicalGlobalObject, throwScope);
9220 return false;
9221 }
9222 auto forwardId = Identifier::fromString(vm, reinterpret_cast<const LChar*>("href"), strlen("href"));
9223 PutPropertySlot slot(valueToForwardTo, false);
9224 asObject(valueToForwardTo)->methodTable(vm)->put(asObject(valueToForwardTo), &lexicalGlobalObject, forwardId, value, slot);
9225 RETURN_IF_EXCEPTION(throwScope, false);
9226 return true;
9227}
9228
9229JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_location, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
9230{
9231 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_locationSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
9232}
9233
9234static inline JSValue jsDOMWindow_historyGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
9235{
9236 auto& vm = JSC::getVM(&lexicalGlobalObject);
9237 auto throwScope = DECLARE_THROW_SCOPE(vm);
9238 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9239 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9240 if (!shouldAllowAccess)
9241 return jsUndefined();
9242 auto& impl = thisObject.wrapped();
9243 RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<History>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.history())));
9244}
9245
9246JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_history, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
9247{
9248 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_historyGetter>(*lexicalGlobalObject, thisValue, attributeName);
9249}
9250
9251static inline JSValue jsDOMWindow_customElementsGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
9252{
9253 auto& vm = JSC::getVM(&lexicalGlobalObject);
9254 auto throwScope = DECLARE_THROW_SCOPE(vm);
9255 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9256 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9257 if (!shouldAllowAccess)
9258 return jsUndefined();
9259 auto& impl = thisObject.wrapped();
9260 RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<CustomElementRegistry>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.ensureCustomElementRegistry())));
9261}
9262
9263JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_customElements, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
9264{
9265 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_customElementsGetter>(*lexicalGlobalObject, thisValue, attributeName);
9266}
9267
9268static inline JSValue jsDOMWindow_locationbarGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
9269{
9270 auto& vm = JSC::getVM(&lexicalGlobalObject);
9271 auto throwScope = DECLARE_THROW_SCOPE(vm);
9272 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9273 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9274 if (!shouldAllowAccess)
9275 return jsUndefined();
9276 auto& impl = thisObject.wrapped();
9277 RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<BarProp>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.locationbar())));
9278}
9279
9280JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_locationbar, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
9281{
9282 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_locationbarGetter>(*lexicalGlobalObject, thisValue, attributeName);
9283}
9284
9285static inline bool setJSDOMWindow_locationbarSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
9286{
9287 auto& vm = JSC::getVM(&lexicalGlobalObject);
9288 auto throwScope = DECLARE_THROW_SCOPE(vm);
9289 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9290 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9291 if (!shouldAllowAccess)
9292 return false;
9293 // Shadowing a built-in property.
9294 return replaceStaticPropertySlot(vm, &thisObject, Identifier::fromString(vm, reinterpret_cast<const LChar*>("locationbar"), strlen("locationbar")), value);
9295}
9296
9297JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_locationbar, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
9298{
9299 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_locationbarSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
9300}
9301
9302static inline JSValue jsDOMWindow_menubarGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
9303{
9304 auto& vm = JSC::getVM(&lexicalGlobalObject);
9305 auto throwScope = DECLARE_THROW_SCOPE(vm);
9306 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9307 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9308 if (!shouldAllowAccess)
9309 return jsUndefined();
9310 auto& impl = thisObject.wrapped();
9311 RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<BarProp>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.menubar())));
9312}
9313
9314JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_menubar, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
9315{
9316 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_menubarGetter>(*lexicalGlobalObject, thisValue, attributeName);
9317}
9318
9319static inline bool setJSDOMWindow_menubarSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
9320{
9321 auto& vm = JSC::getVM(&lexicalGlobalObject);
9322 auto throwScope = DECLARE_THROW_SCOPE(vm);
9323 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9324 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9325 if (!shouldAllowAccess)
9326 return false;
9327 // Shadowing a built-in property.
9328 return replaceStaticPropertySlot(vm, &thisObject, Identifier::fromString(vm, reinterpret_cast<const LChar*>("menubar"), strlen("menubar")), value);
9329}
9330
9331JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_menubar, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
9332{
9333 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_menubarSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
9334}
9335
9336static inline JSValue jsDOMWindow_personalbarGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
9337{
9338 auto& vm = JSC::getVM(&lexicalGlobalObject);
9339 auto throwScope = DECLARE_THROW_SCOPE(vm);
9340 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9341 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9342 if (!shouldAllowAccess)
9343 return jsUndefined();
9344 auto& impl = thisObject.wrapped();
9345 RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<BarProp>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.personalbar())));
9346}
9347
9348JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_personalbar, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
9349{
9350 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_personalbarGetter>(*lexicalGlobalObject, thisValue, attributeName);
9351}
9352
9353static inline bool setJSDOMWindow_personalbarSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
9354{
9355 auto& vm = JSC::getVM(&lexicalGlobalObject);
9356 auto throwScope = DECLARE_THROW_SCOPE(vm);
9357 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9358 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9359 if (!shouldAllowAccess)
9360 return false;
9361 // Shadowing a built-in property.
9362 return replaceStaticPropertySlot(vm, &thisObject, Identifier::fromString(vm, reinterpret_cast<const LChar*>("personalbar"), strlen("personalbar")), value);
9363}
9364
9365JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_personalbar, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
9366{
9367 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_personalbarSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
9368}
9369
9370static inline JSValue jsDOMWindow_scrollbarsGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
9371{
9372 auto& vm = JSC::getVM(&lexicalGlobalObject);
9373 auto throwScope = DECLARE_THROW_SCOPE(vm);
9374 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9375 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9376 if (!shouldAllowAccess)
9377 return jsUndefined();
9378 auto& impl = thisObject.wrapped();
9379 RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<BarProp>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.scrollbars())));
9380}
9381
9382JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_scrollbars, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
9383{
9384 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_scrollbarsGetter>(*lexicalGlobalObject, thisValue, attributeName);
9385}
9386
9387static inline bool setJSDOMWindow_scrollbarsSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
9388{
9389 auto& vm = JSC::getVM(&lexicalGlobalObject);
9390 auto throwScope = DECLARE_THROW_SCOPE(vm);
9391 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9392 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9393 if (!shouldAllowAccess)
9394 return false;
9395 // Shadowing a built-in property.
9396 return replaceStaticPropertySlot(vm, &thisObject, Identifier::fromString(vm, reinterpret_cast<const LChar*>("scrollbars"), strlen("scrollbars")), value);
9397}
9398
9399JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_scrollbars, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
9400{
9401 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_scrollbarsSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
9402}
9403
9404static inline JSValue jsDOMWindow_statusbarGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
9405{
9406 auto& vm = JSC::getVM(&lexicalGlobalObject);
9407 auto throwScope = DECLARE_THROW_SCOPE(vm);
9408 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9409 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9410 if (!shouldAllowAccess)
9411 return jsUndefined();
9412 auto& impl = thisObject.wrapped();
9413 RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<BarProp>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.statusbar())));
9414}
9415
9416JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_statusbar, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
9417{
9418 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_statusbarGetter>(*lexicalGlobalObject, thisValue, attributeName);
9419}
9420
9421static inline bool setJSDOMWindow_statusbarSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
9422{
9423 auto& vm = JSC::getVM(&lexicalGlobalObject);
9424 auto throwScope = DECLARE_THROW_SCOPE(vm);
9425 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9426 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9427 if (!shouldAllowAccess)
9428 return false;
9429 // Shadowing a built-in property.
9430 return replaceStaticPropertySlot(vm, &thisObject, Identifier::fromString(vm, reinterpret_cast<const LChar*>("statusbar"), strlen("statusbar")), value);
9431}
9432
9433JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_statusbar, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
9434{
9435 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_statusbarSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
9436}
9437
9438static inline JSValue jsDOMWindow_toolbarGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
9439{
9440 auto& vm = JSC::getVM(&lexicalGlobalObject);
9441 auto throwScope = DECLARE_THROW_SCOPE(vm);
9442 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9443 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9444 if (!shouldAllowAccess)
9445 return jsUndefined();
9446 auto& impl = thisObject.wrapped();
9447 RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<BarProp>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.toolbar())));
9448}
9449
9450JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_toolbar, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
9451{
9452 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_toolbarGetter>(*lexicalGlobalObject, thisValue, attributeName);
9453}
9454
9455static inline bool setJSDOMWindow_toolbarSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
9456{
9457 auto& vm = JSC::getVM(&lexicalGlobalObject);
9458 auto throwScope = DECLARE_THROW_SCOPE(vm);
9459 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9460 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9461 if (!shouldAllowAccess)
9462 return false;
9463 // Shadowing a built-in property.
9464 return replaceStaticPropertySlot(vm, &thisObject, Identifier::fromString(vm, reinterpret_cast<const LChar*>("toolbar"), strlen("toolbar")), value);
9465}
9466
9467JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_toolbar, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
9468{
9469 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_toolbarSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
9470}
9471
9472static inline JSValue jsDOMWindow_statusGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
9473{
9474 auto& vm = JSC::getVM(&lexicalGlobalObject);
9475 auto throwScope = DECLARE_THROW_SCOPE(vm);
9476 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9477 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9478 if (!shouldAllowAccess)
9479 return jsUndefined();
9480 auto& impl = thisObject.wrapped();
9481 RELEASE_AND_RETURN(throwScope, (toJS<IDLDOMString>(lexicalGlobalObject, throwScope, impl.status())));
9482}
9483
9484JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_status, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
9485{
9486 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_statusGetter>(*lexicalGlobalObject, thisValue, attributeName);
9487}
9488
9489static inline bool setJSDOMWindow_statusSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
9490{
9491 auto& vm = JSC::getVM(&lexicalGlobalObject);
9492 auto throwScope = DECLARE_THROW_SCOPE(vm);
9493 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9494 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9495 if (!shouldAllowAccess)
9496 return false;
9497 auto& impl = thisObject.wrapped();
9498 auto nativeValue = convert<IDLDOMString>(lexicalGlobalObject, value);
9499 RETURN_IF_EXCEPTION(throwScope, false);
9500 invokeFunctorPropagatingExceptionIfNecessary(lexicalGlobalObject, throwScope, [&] {
9501 return impl.setStatus(WTFMove(nativeValue));
9502 });
9503 return true;
9504}
9505
9506JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_status, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
9507{
9508 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_statusSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
9509}
9510
9511static inline JSValue jsDOMWindow_closedGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
9512{
9513 auto& vm = JSC::getVM(&lexicalGlobalObject);
9514 auto throwScope = DECLARE_THROW_SCOPE(vm);
9515 auto& impl = thisObject.wrapped();
9516 RELEASE_AND_RETURN(throwScope, (toJS<IDLBoolean>(lexicalGlobalObject, throwScope, impl.closed())));
9517}
9518
9519JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_closed, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
9520{
9521 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_closedGetter>(*lexicalGlobalObject, thisValue, attributeName);
9522}
9523
9524static inline JSValue jsDOMWindow_framesGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
9525{
9526 UNUSED_PARAM(lexicalGlobalObject);
9527 return thisObject.frames(lexicalGlobalObject);
9528}
9529
9530JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_frames, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
9531{
9532 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_framesGetter>(*lexicalGlobalObject, thisValue, attributeName);
9533}
9534
9535static inline bool setJSDOMWindow_framesSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
9536{
9537 auto& vm = JSC::getVM(&lexicalGlobalObject);
9538 auto throwScope = DECLARE_THROW_SCOPE(vm);
9539 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9540 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9541 if (!shouldAllowAccess)
9542 return false;
9543 // Shadowing a built-in property.
9544 return replaceStaticPropertySlot(vm, &thisObject, Identifier::fromString(vm, reinterpret_cast<const LChar*>("frames"), strlen("frames")), value);
9545}
9546
9547JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_frames, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
9548{
9549 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_framesSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
9550}
9551
9552static inline JSValue jsDOMWindow_lengthGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
9553{
9554 auto& vm = JSC::getVM(&lexicalGlobalObject);
9555 auto throwScope = DECLARE_THROW_SCOPE(vm);
9556 auto& impl = thisObject.wrapped();
9557 RELEASE_AND_RETURN(throwScope, (toJS<IDLUnsignedLong>(lexicalGlobalObject, throwScope, impl.length())));
9558}
9559
9560JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_length, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
9561{
9562 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_lengthGetter>(*lexicalGlobalObject, thisValue, attributeName);
9563}
9564
9565static inline bool setJSDOMWindow_lengthSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
9566{
9567 auto& vm = JSC::getVM(&lexicalGlobalObject);
9568 auto throwScope = DECLARE_THROW_SCOPE(vm);
9569 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9570 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9571 if (!shouldAllowAccess)
9572 return false;
9573 // Shadowing a built-in property.
9574 return replaceStaticPropertySlot(vm, &thisObject, Identifier::fromString(vm, reinterpret_cast<const LChar*>("length"), strlen("length")), value);
9575}
9576
9577JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_length, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
9578{
9579 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_lengthSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
9580}
9581
9582static inline JSValue jsDOMWindow_topGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
9583{
9584 auto& vm = JSC::getVM(&lexicalGlobalObject);
9585 auto throwScope = DECLARE_THROW_SCOPE(vm);
9586 auto& impl = thisObject.wrapped();
9587 RELEASE_AND_RETURN(throwScope, (toJS<IDLNullable<IDLInterface<WindowProxy>>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.top())));
9588}
9589
9590JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_top, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
9591{
9592 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_topGetter>(*lexicalGlobalObject, thisValue, attributeName);
9593}
9594
9595static inline JSValue jsDOMWindow_openerGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
9596{
9597 auto& vm = JSC::getVM(&lexicalGlobalObject);
9598 auto throwScope = DECLARE_THROW_SCOPE(vm);
9599 auto& impl = thisObject.wrapped();
9600 RELEASE_AND_RETURN(throwScope, (toJS<IDLNullable<IDLInterface<WindowProxy>>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.opener())));
9601}
9602
9603JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_opener, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
9604{
9605 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_openerGetter>(*lexicalGlobalObject, thisValue, attributeName);
9606}
9607
9608static inline bool setJSDOMWindow_openerSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
9609{
9610 auto& vm = JSC::getVM(&lexicalGlobalObject);
9611 auto throwScope = DECLARE_THROW_SCOPE(vm);
9612 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9613 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9614 if (!shouldAllowAccess)
9615 return false;
9616 thisObject.setOpener(lexicalGlobalObject, value);
9617 return true;
9618}
9619
9620JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_opener, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
9621{
9622 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_openerSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
9623}
9624
9625static inline JSValue jsDOMWindow_parentGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
9626{
9627 auto& vm = JSC::getVM(&lexicalGlobalObject);
9628 auto throwScope = DECLARE_THROW_SCOPE(vm);
9629 auto& impl = thisObject.wrapped();
9630 RELEASE_AND_RETURN(throwScope, (toJS<IDLNullable<IDLInterface<WindowProxy>>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.parent())));
9631}
9632
9633JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_parent, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
9634{
9635 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_parentGetter>(*lexicalGlobalObject, thisValue, attributeName);
9636}
9637
9638static inline bool setJSDOMWindow_parentSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
9639{
9640 auto& vm = JSC::getVM(&lexicalGlobalObject);
9641 auto throwScope = DECLARE_THROW_SCOPE(vm);
9642 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9643 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9644 if (!shouldAllowAccess)
9645 return false;
9646 // Shadowing a built-in property.
9647 return replaceStaticPropertySlot(vm, &thisObject, Identifier::fromString(vm, reinterpret_cast<const LChar*>("parent"), strlen("parent")), value);
9648}
9649
9650JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_parent, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
9651{
9652 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_parentSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
9653}
9654
9655static inline JSValue jsDOMWindow_frameElementGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
9656{
9657 auto& vm = JSC::getVM(&lexicalGlobalObject);
9658 auto throwScope = DECLARE_THROW_SCOPE(vm);
9659 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9660 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9661 if (!shouldAllowAccess)
9662 return jsUndefined();
9663 auto& impl = thisObject.wrapped();
9664 RELEASE_AND_RETURN(throwScope, (toJS<IDLNullable<IDLInterface<Element>>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, BindingSecurity::checkSecurityForNode(lexicalGlobalObject, impl.frameElement()))));
9665}
9666
9667JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_frameElement, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
9668{
9669 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_frameElementGetter>(*lexicalGlobalObject, thisValue, attributeName);
9670}
9671
9672static inline JSValue jsDOMWindow_navigatorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
9673{
9674 auto& vm = JSC::getVM(&lexicalGlobalObject);
9675 auto throwScope = DECLARE_THROW_SCOPE(vm);
9676 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9677 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9678 if (!shouldAllowAccess)
9679 return jsUndefined();
9680 auto& impl = thisObject.wrapped();
9681 RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<Navigator>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.navigator())));
9682}
9683
9684JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_navigator, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
9685{
9686 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_navigatorGetter>(*lexicalGlobalObject, thisValue, attributeName);
9687}
9688
9689static inline JSValue jsDOMWindow_applicationCacheGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
9690{
9691 auto& vm = JSC::getVM(&lexicalGlobalObject);
9692 auto throwScope = DECLARE_THROW_SCOPE(vm);
9693 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9694 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9695 if (!shouldAllowAccess)
9696 return jsUndefined();
9697 auto& impl = thisObject.wrapped();
9698 RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<DOMApplicationCache>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.applicationCache())));
9699}
9700
9701JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_applicationCache, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
9702{
9703 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_applicationCacheGetter>(*lexicalGlobalObject, thisValue, attributeName);
9704}
9705
9706static inline JSValue jsDOMWindow_eventGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
9707{
9708 auto& vm = JSC::getVM(&lexicalGlobalObject);
9709 auto throwScope = DECLARE_THROW_SCOPE(vm);
9710 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9711 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9712 if (!shouldAllowAccess)
9713 return jsUndefined();
9714 return thisObject.event(lexicalGlobalObject);
9715}
9716
9717JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_event, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
9718{
9719 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_eventGetter>(*lexicalGlobalObject, thisValue, attributeName);
9720}
9721
9722static inline bool setJSDOMWindow_eventSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
9723{
9724 auto& vm = JSC::getVM(&lexicalGlobalObject);
9725 auto throwScope = DECLARE_THROW_SCOPE(vm);
9726 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9727 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9728 if (!shouldAllowAccess)
9729 return false;
9730 // Shadowing a built-in property.
9731 return replaceStaticPropertySlot(vm, &thisObject, Identifier::fromString(vm, reinterpret_cast<const LChar*>("event"), strlen("event")), value);
9732}
9733
9734JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_event, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
9735{
9736 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_eventSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
9737}
9738
9739static inline JSValue jsDOMWindow_defaultStatusGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
9740{
9741 auto& vm = JSC::getVM(&lexicalGlobalObject);
9742 auto throwScope = DECLARE_THROW_SCOPE(vm);
9743 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9744 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9745 if (!shouldAllowAccess)
9746 return jsUndefined();
9747 auto& impl = thisObject.wrapped();
9748 RELEASE_AND_RETURN(throwScope, (toJS<IDLDOMString>(lexicalGlobalObject, throwScope, impl.defaultStatus())));
9749}
9750
9751JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_defaultStatus, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
9752{
9753 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_defaultStatusGetter>(*lexicalGlobalObject, thisValue, attributeName);
9754}
9755
9756static inline bool setJSDOMWindow_defaultStatusSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
9757{
9758 auto& vm = JSC::getVM(&lexicalGlobalObject);
9759 auto throwScope = DECLARE_THROW_SCOPE(vm);
9760 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9761 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9762 if (!shouldAllowAccess)
9763 return false;
9764 auto& impl = thisObject.wrapped();
9765 auto nativeValue = convert<IDLDOMString>(lexicalGlobalObject, value);
9766 RETURN_IF_EXCEPTION(throwScope, false);
9767 invokeFunctorPropagatingExceptionIfNecessary(lexicalGlobalObject, throwScope, [&] {
9768 return impl.setDefaultStatus(WTFMove(nativeValue));
9769 });
9770 return true;
9771}
9772
9773JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_defaultStatus, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
9774{
9775 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_defaultStatusSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
9776}
9777
9778static inline JSValue jsDOMWindow_defaultstatusGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
9779{
9780 auto& vm = JSC::getVM(&lexicalGlobalObject);
9781 auto throwScope = DECLARE_THROW_SCOPE(vm);
9782 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9783 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9784 if (!shouldAllowAccess)
9785 return jsUndefined();
9786 auto& impl = thisObject.wrapped();
9787 RELEASE_AND_RETURN(throwScope, (toJS<IDLDOMString>(lexicalGlobalObject, throwScope, impl.defaultStatus())));
9788}
9789
9790JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_defaultstatus, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
9791{
9792 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_defaultstatusGetter>(*lexicalGlobalObject, thisValue, attributeName);
9793}
9794
9795static inline bool setJSDOMWindow_defaultstatusSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
9796{
9797 auto& vm = JSC::getVM(&lexicalGlobalObject);
9798 auto throwScope = DECLARE_THROW_SCOPE(vm);
9799 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9800 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9801 if (!shouldAllowAccess)
9802 return false;
9803 auto& impl = thisObject.wrapped();
9804 auto nativeValue = convert<IDLDOMString>(lexicalGlobalObject, value);
9805 RETURN_IF_EXCEPTION(throwScope, false);
9806 invokeFunctorPropagatingExceptionIfNecessary(lexicalGlobalObject, throwScope, [&] {
9807 return impl.setDefaultStatus(WTFMove(nativeValue));
9808 });
9809 return true;
9810}
9811
9812JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_defaultstatus, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
9813{
9814 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_defaultstatusSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
9815}
9816
9817static inline JSValue jsDOMWindow_offscreenBufferingGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
9818{
9819 auto& vm = JSC::getVM(&lexicalGlobalObject);
9820 auto throwScope = DECLARE_THROW_SCOPE(vm);
9821 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9822 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9823 if (!shouldAllowAccess)
9824 return jsUndefined();
9825 auto& impl = thisObject.wrapped();
9826 RELEASE_AND_RETURN(throwScope, (toJS<IDLBoolean>(lexicalGlobalObject, throwScope, impl.offscreenBuffering())));
9827}
9828
9829JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_offscreenBuffering, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
9830{
9831 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_offscreenBufferingGetter>(*lexicalGlobalObject, thisValue, attributeName);
9832}
9833
9834static inline bool setJSDOMWindow_offscreenBufferingSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
9835{
9836 auto& vm = JSC::getVM(&lexicalGlobalObject);
9837 auto throwScope = DECLARE_THROW_SCOPE(vm);
9838 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9839 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9840 if (!shouldAllowAccess)
9841 return false;
9842 // Shadowing a built-in property.
9843 return replaceStaticPropertySlot(vm, &thisObject, Identifier::fromString(vm, reinterpret_cast<const LChar*>("offscreenBuffering"), strlen("offscreenBuffering")), value);
9844}
9845
9846JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_offscreenBuffering, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
9847{
9848 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_offscreenBufferingSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
9849}
9850
9851static inline JSValue jsDOMWindow_clientInformationGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
9852{
9853 auto& vm = JSC::getVM(&lexicalGlobalObject);
9854 auto throwScope = DECLARE_THROW_SCOPE(vm);
9855 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9856 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9857 if (!shouldAllowAccess)
9858 return jsUndefined();
9859 auto& impl = thisObject.wrapped();
9860 RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<Navigator>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.clientInformation())));
9861}
9862
9863JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_clientInformation, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
9864{
9865 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_clientInformationGetter>(*lexicalGlobalObject, thisValue, attributeName);
9866}
9867
9868static inline bool setJSDOMWindow_clientInformationSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
9869{
9870 auto& vm = JSC::getVM(&lexicalGlobalObject);
9871 auto throwScope = DECLARE_THROW_SCOPE(vm);
9872 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9873 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9874 if (!shouldAllowAccess)
9875 return false;
9876 // Shadowing a built-in property.
9877 return replaceStaticPropertySlot(vm, &thisObject, Identifier::fromString(vm, reinterpret_cast<const LChar*>("clientInformation"), strlen("clientInformation")), value);
9878}
9879
9880JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_clientInformation, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
9881{
9882 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_clientInformationSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
9883}
9884
9885#if ENABLE(IOS_GESTURE_EVENTS)
9886static inline JSValue jsDOMWindow_ongesturechangeGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
9887{
9888 auto& vm = JSC::getVM(&lexicalGlobalObject);
9889 auto throwScope = DECLARE_THROW_SCOPE(vm);
9890 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9891 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9892 if (!shouldAllowAccess)
9893 return jsUndefined();
9894 return eventHandlerAttribute(thisObject.wrapped(), eventNames().gesturechangeEvent, worldForDOMObject(thisObject));
9895}
9896
9897JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ongesturechange, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
9898{
9899 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ongesturechangeGetter>(*lexicalGlobalObject, thisValue, attributeName);
9900}
9901
9902#endif
9903
9904#if ENABLE(IOS_GESTURE_EVENTS)
9905static inline bool setJSDOMWindow_ongesturechangeSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
9906{
9907 auto& vm = JSC::getVM(&lexicalGlobalObject);
9908 auto throwScope = DECLARE_THROW_SCOPE(vm);
9909 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9910 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9911 if (!shouldAllowAccess)
9912 return false;
9913 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().gesturechangeEvent, value);
9914 vm.heap.writeBarrier(&thisObject, value);
9915 ensureStillAliveHere(value);
9916
9917 return true;
9918}
9919
9920JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_ongesturechange, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
9921{
9922 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_ongesturechangeSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
9923}
9924
9925#endif
9926
9927#if ENABLE(IOS_GESTURE_EVENTS)
9928static inline JSValue jsDOMWindow_ongestureendGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
9929{
9930 auto& vm = JSC::getVM(&lexicalGlobalObject);
9931 auto throwScope = DECLARE_THROW_SCOPE(vm);
9932 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9933 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9934 if (!shouldAllowAccess)
9935 return jsUndefined();
9936 return eventHandlerAttribute(thisObject.wrapped(), eventNames().gestureendEvent, worldForDOMObject(thisObject));
9937}
9938
9939JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ongestureend, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
9940{
9941 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ongestureendGetter>(*lexicalGlobalObject, thisValue, attributeName);
9942}
9943
9944#endif
9945
9946#if ENABLE(IOS_GESTURE_EVENTS)
9947static inline bool setJSDOMWindow_ongestureendSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
9948{
9949 auto& vm = JSC::getVM(&lexicalGlobalObject);
9950 auto throwScope = DECLARE_THROW_SCOPE(vm);
9951 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9952 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9953 if (!shouldAllowAccess)
9954 return false;
9955 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().gestureendEvent, value);
9956 vm.heap.writeBarrier(&thisObject, value);
9957 ensureStillAliveHere(value);
9958
9959 return true;
9960}
9961
9962JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_ongestureend, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
9963{
9964 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_ongestureendSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
9965}
9966
9967#endif
9968
9969#if ENABLE(IOS_GESTURE_EVENTS)
9970static inline JSValue jsDOMWindow_ongesturestartGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
9971{
9972 auto& vm = JSC::getVM(&lexicalGlobalObject);
9973 auto throwScope = DECLARE_THROW_SCOPE(vm);
9974 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9975 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9976 if (!shouldAllowAccess)
9977 return jsUndefined();
9978 return eventHandlerAttribute(thisObject.wrapped(), eventNames().gesturestartEvent, worldForDOMObject(thisObject));
9979}
9980
9981JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ongesturestart, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
9982{
9983 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ongesturestartGetter>(*lexicalGlobalObject, thisValue, attributeName);
9984}
9985
9986#endif
9987
9988#if ENABLE(IOS_GESTURE_EVENTS)
9989static inline bool setJSDOMWindow_ongesturestartSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
9990{
9991 auto& vm = JSC::getVM(&lexicalGlobalObject);
9992 auto throwScope = DECLARE_THROW_SCOPE(vm);
9993 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
9994 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
9995 if (!shouldAllowAccess)
9996 return false;
9997 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().gesturestartEvent, value);
9998 vm.heap.writeBarrier(&thisObject, value);
9999 ensureStillAliveHere(value);
10000
10001 return true;
10002}
10003
10004JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_ongesturestart, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
10005{
10006 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_ongesturestartSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
10007}
10008
10009#endif
10010
10011#if ENABLE(SPEECH_SYNTHESIS)
10012static inline JSValue jsDOMWindow_speechSynthesisGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
10013{
10014 auto& vm = JSC::getVM(&lexicalGlobalObject);
10015 auto throwScope = DECLARE_THROW_SCOPE(vm);
10016 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10017 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10018 if (!shouldAllowAccess)
10019 return jsUndefined();
10020 auto& impl = thisObject.wrapped();
10021 RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<SpeechSynthesis>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, WebCore::DOMWindowSpeechSynthesis::speechSynthesis(impl))));
10022}
10023
10024JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_speechSynthesis, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
10025{
10026 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_speechSynthesisGetter>(*lexicalGlobalObject, thisValue, attributeName);
10027}
10028
10029#endif
10030
10031static inline JSValue jsDOMWindow_openDatabaseGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
10032{
10033 auto& vm = JSC::getVM(&lexicalGlobalObject);
10034 auto throwScope = DECLARE_THROW_SCOPE(vm);
10035 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10036 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10037 if (!shouldAllowAccess)
10038 return jsUndefined();
10039 return thisObject.openDatabase(lexicalGlobalObject);
10040}
10041
10042JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_openDatabase, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
10043{
10044 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_openDatabaseGetter>(*lexicalGlobalObject, thisValue, attributeName);
10045}
10046
10047static inline bool setJSDOMWindow_openDatabaseSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
10048{
10049 auto& vm = JSC::getVM(&lexicalGlobalObject);
10050 auto throwScope = DECLARE_THROW_SCOPE(vm);
10051 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10052 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10053 if (!shouldAllowAccess)
10054 return false;
10055 thisObject.setOpenDatabase(lexicalGlobalObject, value);
10056 return true;
10057}
10058
10059JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_openDatabase, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
10060{
10061 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_openDatabaseSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
10062}
10063
10064static inline JSValue jsDOMWindow_onabortGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
10065{
10066 auto& vm = JSC::getVM(&lexicalGlobalObject);
10067 auto throwScope = DECLARE_THROW_SCOPE(vm);
10068 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10069 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10070 if (!shouldAllowAccess)
10071 return jsUndefined();
10072 return eventHandlerAttribute(thisObject.wrapped(), eventNames().abortEvent, worldForDOMObject(thisObject));
10073}
10074
10075JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onabort, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
10076{
10077 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onabortGetter>(*lexicalGlobalObject, thisValue, attributeName);
10078}
10079
10080static inline bool setJSDOMWindow_onabortSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
10081{
10082 auto& vm = JSC::getVM(&lexicalGlobalObject);
10083 auto throwScope = DECLARE_THROW_SCOPE(vm);
10084 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10085 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10086 if (!shouldAllowAccess)
10087 return false;
10088 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().abortEvent, value);
10089 vm.heap.writeBarrier(&thisObject, value);
10090 ensureStillAliveHere(value);
10091
10092 return true;
10093}
10094
10095JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onabort, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
10096{
10097 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onabortSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
10098}
10099
10100static inline JSValue jsDOMWindow_onblurGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
10101{
10102 auto& vm = JSC::getVM(&lexicalGlobalObject);
10103 auto throwScope = DECLARE_THROW_SCOPE(vm);
10104 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10105 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10106 if (!shouldAllowAccess)
10107 return jsUndefined();
10108 return eventHandlerAttribute(thisObject.wrapped(), eventNames().blurEvent, worldForDOMObject(thisObject));
10109}
10110
10111JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onblur, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
10112{
10113 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onblurGetter>(*lexicalGlobalObject, thisValue, attributeName);
10114}
10115
10116static inline bool setJSDOMWindow_onblurSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
10117{
10118 auto& vm = JSC::getVM(&lexicalGlobalObject);
10119 auto throwScope = DECLARE_THROW_SCOPE(vm);
10120 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10121 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10122 if (!shouldAllowAccess)
10123 return false;
10124 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().blurEvent, value);
10125 vm.heap.writeBarrier(&thisObject, value);
10126 ensureStillAliveHere(value);
10127
10128 return true;
10129}
10130
10131JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onblur, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
10132{
10133 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onblurSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
10134}
10135
10136static inline JSValue jsDOMWindow_oncanplayGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
10137{
10138 auto& vm = JSC::getVM(&lexicalGlobalObject);
10139 auto throwScope = DECLARE_THROW_SCOPE(vm);
10140 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10141 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10142 if (!shouldAllowAccess)
10143 return jsUndefined();
10144 return eventHandlerAttribute(thisObject.wrapped(), eventNames().canplayEvent, worldForDOMObject(thisObject));
10145}
10146
10147JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_oncanplay, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
10148{
10149 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_oncanplayGetter>(*lexicalGlobalObject, thisValue, attributeName);
10150}
10151
10152static inline bool setJSDOMWindow_oncanplaySetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
10153{
10154 auto& vm = JSC::getVM(&lexicalGlobalObject);
10155 auto throwScope = DECLARE_THROW_SCOPE(vm);
10156 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10157 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10158 if (!shouldAllowAccess)
10159 return false;
10160 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().canplayEvent, value);
10161 vm.heap.writeBarrier(&thisObject, value);
10162 ensureStillAliveHere(value);
10163
10164 return true;
10165}
10166
10167JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_oncanplay, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
10168{
10169 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_oncanplaySetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
10170}
10171
10172static inline JSValue jsDOMWindow_oncanplaythroughGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
10173{
10174 auto& vm = JSC::getVM(&lexicalGlobalObject);
10175 auto throwScope = DECLARE_THROW_SCOPE(vm);
10176 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10177 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10178 if (!shouldAllowAccess)
10179 return jsUndefined();
10180 return eventHandlerAttribute(thisObject.wrapped(), eventNames().canplaythroughEvent, worldForDOMObject(thisObject));
10181}
10182
10183JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_oncanplaythrough, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
10184{
10185 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_oncanplaythroughGetter>(*lexicalGlobalObject, thisValue, attributeName);
10186}
10187
10188static inline bool setJSDOMWindow_oncanplaythroughSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
10189{
10190 auto& vm = JSC::getVM(&lexicalGlobalObject);
10191 auto throwScope = DECLARE_THROW_SCOPE(vm);
10192 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10193 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10194 if (!shouldAllowAccess)
10195 return false;
10196 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().canplaythroughEvent, value);
10197 vm.heap.writeBarrier(&thisObject, value);
10198 ensureStillAliveHere(value);
10199
10200 return true;
10201}
10202
10203JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_oncanplaythrough, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
10204{
10205 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_oncanplaythroughSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
10206}
10207
10208static inline JSValue jsDOMWindow_onchangeGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
10209{
10210 auto& vm = JSC::getVM(&lexicalGlobalObject);
10211 auto throwScope = DECLARE_THROW_SCOPE(vm);
10212 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10213 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10214 if (!shouldAllowAccess)
10215 return jsUndefined();
10216 return eventHandlerAttribute(thisObject.wrapped(), eventNames().changeEvent, worldForDOMObject(thisObject));
10217}
10218
10219JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onchange, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
10220{
10221 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onchangeGetter>(*lexicalGlobalObject, thisValue, attributeName);
10222}
10223
10224static inline bool setJSDOMWindow_onchangeSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
10225{
10226 auto& vm = JSC::getVM(&lexicalGlobalObject);
10227 auto throwScope = DECLARE_THROW_SCOPE(vm);
10228 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10229 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10230 if (!shouldAllowAccess)
10231 return false;
10232 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().changeEvent, value);
10233 vm.heap.writeBarrier(&thisObject, value);
10234 ensureStillAliveHere(value);
10235
10236 return true;
10237}
10238
10239JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onchange, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
10240{
10241 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onchangeSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
10242}
10243
10244static inline JSValue jsDOMWindow_onclickGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
10245{
10246 auto& vm = JSC::getVM(&lexicalGlobalObject);
10247 auto throwScope = DECLARE_THROW_SCOPE(vm);
10248 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10249 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10250 if (!shouldAllowAccess)
10251 return jsUndefined();
10252 return eventHandlerAttribute(thisObject.wrapped(), eventNames().clickEvent, worldForDOMObject(thisObject));
10253}
10254
10255JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onclick, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
10256{
10257 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onclickGetter>(*lexicalGlobalObject, thisValue, attributeName);
10258}
10259
10260static inline bool setJSDOMWindow_onclickSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
10261{
10262 auto& vm = JSC::getVM(&lexicalGlobalObject);
10263 auto throwScope = DECLARE_THROW_SCOPE(vm);
10264 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10265 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10266 if (!shouldAllowAccess)
10267 return false;
10268 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().clickEvent, value);
10269 vm.heap.writeBarrier(&thisObject, value);
10270 ensureStillAliveHere(value);
10271
10272 return true;
10273}
10274
10275JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onclick, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
10276{
10277 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onclickSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
10278}
10279
10280static inline JSValue jsDOMWindow_oncloseGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
10281{
10282 auto& vm = JSC::getVM(&lexicalGlobalObject);
10283 auto throwScope = DECLARE_THROW_SCOPE(vm);
10284 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10285 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10286 if (!shouldAllowAccess)
10287 return jsUndefined();
10288 return eventHandlerAttribute(thisObject.wrapped(), eventNames().closeEvent, worldForDOMObject(thisObject));
10289}
10290
10291JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onclose, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
10292{
10293 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_oncloseGetter>(*lexicalGlobalObject, thisValue, attributeName);
10294}
10295
10296static inline bool setJSDOMWindow_oncloseSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
10297{
10298 auto& vm = JSC::getVM(&lexicalGlobalObject);
10299 auto throwScope = DECLARE_THROW_SCOPE(vm);
10300 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10301 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10302 if (!shouldAllowAccess)
10303 return false;
10304 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().closeEvent, value);
10305 vm.heap.writeBarrier(&thisObject, value);
10306 ensureStillAliveHere(value);
10307
10308 return true;
10309}
10310
10311JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onclose, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
10312{
10313 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_oncloseSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
10314}
10315
10316static inline JSValue jsDOMWindow_oncontextmenuGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
10317{
10318 auto& vm = JSC::getVM(&lexicalGlobalObject);
10319 auto throwScope = DECLARE_THROW_SCOPE(vm);
10320 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10321 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10322 if (!shouldAllowAccess)
10323 return jsUndefined();
10324 return eventHandlerAttribute(thisObject.wrapped(), eventNames().contextmenuEvent, worldForDOMObject(thisObject));
10325}
10326
10327JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_oncontextmenu, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
10328{
10329 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_oncontextmenuGetter>(*lexicalGlobalObject, thisValue, attributeName);
10330}
10331
10332static inline bool setJSDOMWindow_oncontextmenuSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
10333{
10334 auto& vm = JSC::getVM(&lexicalGlobalObject);
10335 auto throwScope = DECLARE_THROW_SCOPE(vm);
10336 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10337 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10338 if (!shouldAllowAccess)
10339 return false;
10340 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().contextmenuEvent, value);
10341 vm.heap.writeBarrier(&thisObject, value);
10342 ensureStillAliveHere(value);
10343
10344 return true;
10345}
10346
10347JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_oncontextmenu, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
10348{
10349 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_oncontextmenuSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
10350}
10351
10352static inline JSValue jsDOMWindow_oncuechangeGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
10353{
10354 auto& vm = JSC::getVM(&lexicalGlobalObject);
10355 auto throwScope = DECLARE_THROW_SCOPE(vm);
10356 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10357 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10358 if (!shouldAllowAccess)
10359 return jsUndefined();
10360 return eventHandlerAttribute(thisObject.wrapped(), eventNames().cuechangeEvent, worldForDOMObject(thisObject));
10361}
10362
10363JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_oncuechange, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
10364{
10365 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_oncuechangeGetter>(*lexicalGlobalObject, thisValue, attributeName);
10366}
10367
10368static inline bool setJSDOMWindow_oncuechangeSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
10369{
10370 auto& vm = JSC::getVM(&lexicalGlobalObject);
10371 auto throwScope = DECLARE_THROW_SCOPE(vm);
10372 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10373 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10374 if (!shouldAllowAccess)
10375 return false;
10376 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().cuechangeEvent, value);
10377 vm.heap.writeBarrier(&thisObject, value);
10378 ensureStillAliveHere(value);
10379
10380 return true;
10381}
10382
10383JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_oncuechange, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
10384{
10385 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_oncuechangeSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
10386}
10387
10388static inline JSValue jsDOMWindow_ondblclickGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
10389{
10390 auto& vm = JSC::getVM(&lexicalGlobalObject);
10391 auto throwScope = DECLARE_THROW_SCOPE(vm);
10392 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10393 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10394 if (!shouldAllowAccess)
10395 return jsUndefined();
10396 return eventHandlerAttribute(thisObject.wrapped(), eventNames().dblclickEvent, worldForDOMObject(thisObject));
10397}
10398
10399JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ondblclick, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
10400{
10401 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ondblclickGetter>(*lexicalGlobalObject, thisValue, attributeName);
10402}
10403
10404static inline bool setJSDOMWindow_ondblclickSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
10405{
10406 auto& vm = JSC::getVM(&lexicalGlobalObject);
10407 auto throwScope = DECLARE_THROW_SCOPE(vm);
10408 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10409 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10410 if (!shouldAllowAccess)
10411 return false;
10412 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().dblclickEvent, value);
10413 vm.heap.writeBarrier(&thisObject, value);
10414 ensureStillAliveHere(value);
10415
10416 return true;
10417}
10418
10419JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_ondblclick, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
10420{
10421 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_ondblclickSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
10422}
10423
10424static inline JSValue jsDOMWindow_ondragGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
10425{
10426 auto& vm = JSC::getVM(&lexicalGlobalObject);
10427 auto throwScope = DECLARE_THROW_SCOPE(vm);
10428 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10429 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10430 if (!shouldAllowAccess)
10431 return jsUndefined();
10432 return eventHandlerAttribute(thisObject.wrapped(), eventNames().dragEvent, worldForDOMObject(thisObject));
10433}
10434
10435JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ondrag, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
10436{
10437 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ondragGetter>(*lexicalGlobalObject, thisValue, attributeName);
10438}
10439
10440static inline bool setJSDOMWindow_ondragSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
10441{
10442 auto& vm = JSC::getVM(&lexicalGlobalObject);
10443 auto throwScope = DECLARE_THROW_SCOPE(vm);
10444 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10445 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10446 if (!shouldAllowAccess)
10447 return false;
10448 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().dragEvent, value);
10449 vm.heap.writeBarrier(&thisObject, value);
10450 ensureStillAliveHere(value);
10451
10452 return true;
10453}
10454
10455JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_ondrag, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
10456{
10457 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_ondragSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
10458}
10459
10460static inline JSValue jsDOMWindow_ondragendGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
10461{
10462 auto& vm = JSC::getVM(&lexicalGlobalObject);
10463 auto throwScope = DECLARE_THROW_SCOPE(vm);
10464 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10465 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10466 if (!shouldAllowAccess)
10467 return jsUndefined();
10468 return eventHandlerAttribute(thisObject.wrapped(), eventNames().dragendEvent, worldForDOMObject(thisObject));
10469}
10470
10471JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ondragend, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
10472{
10473 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ondragendGetter>(*lexicalGlobalObject, thisValue, attributeName);
10474}
10475
10476static inline bool setJSDOMWindow_ondragendSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
10477{
10478 auto& vm = JSC::getVM(&lexicalGlobalObject);
10479 auto throwScope = DECLARE_THROW_SCOPE(vm);
10480 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10481 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10482 if (!shouldAllowAccess)
10483 return false;
10484 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().dragendEvent, value);
10485 vm.heap.writeBarrier(&thisObject, value);
10486 ensureStillAliveHere(value);
10487
10488 return true;
10489}
10490
10491JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_ondragend, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
10492{
10493 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_ondragendSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
10494}
10495
10496static inline JSValue jsDOMWindow_ondragenterGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
10497{
10498 auto& vm = JSC::getVM(&lexicalGlobalObject);
10499 auto throwScope = DECLARE_THROW_SCOPE(vm);
10500 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10501 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10502 if (!shouldAllowAccess)
10503 return jsUndefined();
10504 return eventHandlerAttribute(thisObject.wrapped(), eventNames().dragenterEvent, worldForDOMObject(thisObject));
10505}
10506
10507JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ondragenter, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
10508{
10509 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ondragenterGetter>(*lexicalGlobalObject, thisValue, attributeName);
10510}
10511
10512static inline bool setJSDOMWindow_ondragenterSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
10513{
10514 auto& vm = JSC::getVM(&lexicalGlobalObject);
10515 auto throwScope = DECLARE_THROW_SCOPE(vm);
10516 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10517 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10518 if (!shouldAllowAccess)
10519 return false;
10520 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().dragenterEvent, value);
10521 vm.heap.writeBarrier(&thisObject, value);
10522 ensureStillAliveHere(value);
10523
10524 return true;
10525}
10526
10527JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_ondragenter, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
10528{
10529 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_ondragenterSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
10530}
10531
10532static inline JSValue jsDOMWindow_ondragleaveGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
10533{
10534 auto& vm = JSC::getVM(&lexicalGlobalObject);
10535 auto throwScope = DECLARE_THROW_SCOPE(vm);
10536 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10537 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10538 if (!shouldAllowAccess)
10539 return jsUndefined();
10540 return eventHandlerAttribute(thisObject.wrapped(), eventNames().dragleaveEvent, worldForDOMObject(thisObject));
10541}
10542
10543JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ondragleave, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
10544{
10545 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ondragleaveGetter>(*lexicalGlobalObject, thisValue, attributeName);
10546}
10547
10548static inline bool setJSDOMWindow_ondragleaveSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
10549{
10550 auto& vm = JSC::getVM(&lexicalGlobalObject);
10551 auto throwScope = DECLARE_THROW_SCOPE(vm);
10552 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10553 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10554 if (!shouldAllowAccess)
10555 return false;
10556 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().dragleaveEvent, value);
10557 vm.heap.writeBarrier(&thisObject, value);
10558 ensureStillAliveHere(value);
10559
10560 return true;
10561}
10562
10563JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_ondragleave, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
10564{
10565 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_ondragleaveSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
10566}
10567
10568static inline JSValue jsDOMWindow_ondragoverGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
10569{
10570 auto& vm = JSC::getVM(&lexicalGlobalObject);
10571 auto throwScope = DECLARE_THROW_SCOPE(vm);
10572 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10573 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10574 if (!shouldAllowAccess)
10575 return jsUndefined();
10576 return eventHandlerAttribute(thisObject.wrapped(), eventNames().dragoverEvent, worldForDOMObject(thisObject));
10577}
10578
10579JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ondragover, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
10580{
10581 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ondragoverGetter>(*lexicalGlobalObject, thisValue, attributeName);
10582}
10583
10584static inline bool setJSDOMWindow_ondragoverSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
10585{
10586 auto& vm = JSC::getVM(&lexicalGlobalObject);
10587 auto throwScope = DECLARE_THROW_SCOPE(vm);
10588 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10589 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10590 if (!shouldAllowAccess)
10591 return false;
10592 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().dragoverEvent, value);
10593 vm.heap.writeBarrier(&thisObject, value);
10594 ensureStillAliveHere(value);
10595
10596 return true;
10597}
10598
10599JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_ondragover, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
10600{
10601 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_ondragoverSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
10602}
10603
10604static inline JSValue jsDOMWindow_ondragstartGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
10605{
10606 auto& vm = JSC::getVM(&lexicalGlobalObject);
10607 auto throwScope = DECLARE_THROW_SCOPE(vm);
10608 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10609 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10610 if (!shouldAllowAccess)
10611 return jsUndefined();
10612 return eventHandlerAttribute(thisObject.wrapped(), eventNames().dragstartEvent, worldForDOMObject(thisObject));
10613}
10614
10615JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ondragstart, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
10616{
10617 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ondragstartGetter>(*lexicalGlobalObject, thisValue, attributeName);
10618}
10619
10620static inline bool setJSDOMWindow_ondragstartSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
10621{
10622 auto& vm = JSC::getVM(&lexicalGlobalObject);
10623 auto throwScope = DECLARE_THROW_SCOPE(vm);
10624 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10625 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10626 if (!shouldAllowAccess)
10627 return false;
10628 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().dragstartEvent, value);
10629 vm.heap.writeBarrier(&thisObject, value);
10630 ensureStillAliveHere(value);
10631
10632 return true;
10633}
10634
10635JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_ondragstart, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
10636{
10637 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_ondragstartSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
10638}
10639
10640static inline JSValue jsDOMWindow_ondropGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
10641{
10642 auto& vm = JSC::getVM(&lexicalGlobalObject);
10643 auto throwScope = DECLARE_THROW_SCOPE(vm);
10644 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10645 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10646 if (!shouldAllowAccess)
10647 return jsUndefined();
10648 return eventHandlerAttribute(thisObject.wrapped(), eventNames().dropEvent, worldForDOMObject(thisObject));
10649}
10650
10651JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ondrop, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
10652{
10653 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ondropGetter>(*lexicalGlobalObject, thisValue, attributeName);
10654}
10655
10656static inline bool setJSDOMWindow_ondropSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
10657{
10658 auto& vm = JSC::getVM(&lexicalGlobalObject);
10659 auto throwScope = DECLARE_THROW_SCOPE(vm);
10660 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10661 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10662 if (!shouldAllowAccess)
10663 return false;
10664 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().dropEvent, value);
10665 vm.heap.writeBarrier(&thisObject, value);
10666 ensureStillAliveHere(value);
10667
10668 return true;
10669}
10670
10671JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_ondrop, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
10672{
10673 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_ondropSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
10674}
10675
10676static inline JSValue jsDOMWindow_ondurationchangeGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
10677{
10678 auto& vm = JSC::getVM(&lexicalGlobalObject);
10679 auto throwScope = DECLARE_THROW_SCOPE(vm);
10680 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10681 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10682 if (!shouldAllowAccess)
10683 return jsUndefined();
10684 return eventHandlerAttribute(thisObject.wrapped(), eventNames().durationchangeEvent, worldForDOMObject(thisObject));
10685}
10686
10687JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ondurationchange, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
10688{
10689 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ondurationchangeGetter>(*lexicalGlobalObject, thisValue, attributeName);
10690}
10691
10692static inline bool setJSDOMWindow_ondurationchangeSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
10693{
10694 auto& vm = JSC::getVM(&lexicalGlobalObject);
10695 auto throwScope = DECLARE_THROW_SCOPE(vm);
10696 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10697 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10698 if (!shouldAllowAccess)
10699 return false;
10700 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().durationchangeEvent, value);
10701 vm.heap.writeBarrier(&thisObject, value);
10702 ensureStillAliveHere(value);
10703
10704 return true;
10705}
10706
10707JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_ondurationchange, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
10708{
10709 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_ondurationchangeSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
10710}
10711
10712static inline JSValue jsDOMWindow_onemptiedGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
10713{
10714 auto& vm = JSC::getVM(&lexicalGlobalObject);
10715 auto throwScope = DECLARE_THROW_SCOPE(vm);
10716 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10717 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10718 if (!shouldAllowAccess)
10719 return jsUndefined();
10720 return eventHandlerAttribute(thisObject.wrapped(), eventNames().emptiedEvent, worldForDOMObject(thisObject));
10721}
10722
10723JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onemptied, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
10724{
10725 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onemptiedGetter>(*lexicalGlobalObject, thisValue, attributeName);
10726}
10727
10728static inline bool setJSDOMWindow_onemptiedSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
10729{
10730 auto& vm = JSC::getVM(&lexicalGlobalObject);
10731 auto throwScope = DECLARE_THROW_SCOPE(vm);
10732 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10733 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10734 if (!shouldAllowAccess)
10735 return false;
10736 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().emptiedEvent, value);
10737 vm.heap.writeBarrier(&thisObject, value);
10738 ensureStillAliveHere(value);
10739
10740 return true;
10741}
10742
10743JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onemptied, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
10744{
10745 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onemptiedSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
10746}
10747
10748static inline JSValue jsDOMWindow_onendedGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
10749{
10750 auto& vm = JSC::getVM(&lexicalGlobalObject);
10751 auto throwScope = DECLARE_THROW_SCOPE(vm);
10752 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10753 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10754 if (!shouldAllowAccess)
10755 return jsUndefined();
10756 return eventHandlerAttribute(thisObject.wrapped(), eventNames().endedEvent, worldForDOMObject(thisObject));
10757}
10758
10759JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onended, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
10760{
10761 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onendedGetter>(*lexicalGlobalObject, thisValue, attributeName);
10762}
10763
10764static inline bool setJSDOMWindow_onendedSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
10765{
10766 auto& vm = JSC::getVM(&lexicalGlobalObject);
10767 auto throwScope = DECLARE_THROW_SCOPE(vm);
10768 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10769 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10770 if (!shouldAllowAccess)
10771 return false;
10772 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().endedEvent, value);
10773 vm.heap.writeBarrier(&thisObject, value);
10774 ensureStillAliveHere(value);
10775
10776 return true;
10777}
10778
10779JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onended, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
10780{
10781 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onendedSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
10782}
10783
10784static inline JSValue jsDOMWindow_onerrorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
10785{
10786 auto& vm = JSC::getVM(&lexicalGlobalObject);
10787 auto throwScope = DECLARE_THROW_SCOPE(vm);
10788 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10789 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10790 if (!shouldAllowAccess)
10791 return jsUndefined();
10792 return eventHandlerAttribute(thisObject.wrapped(), eventNames().errorEvent, worldForDOMObject(thisObject));
10793}
10794
10795JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onerror, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
10796{
10797 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onerrorGetter>(*lexicalGlobalObject, thisValue, attributeName);
10798}
10799
10800static inline bool setJSDOMWindow_onerrorSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
10801{
10802 auto& vm = JSC::getVM(&lexicalGlobalObject);
10803 auto throwScope = DECLARE_THROW_SCOPE(vm);
10804 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10805 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10806 if (!shouldAllowAccess)
10807 return false;
10808 thisObject.wrapped().setAttributeEventListener(eventNames().errorEvent, createJSErrorHandler(lexicalGlobalObject, value, thisObject), worldForDOMObject(thisObject));
10809 vm.heap.writeBarrier(&thisObject, value);
10810 ensureStillAliveHere(value);
10811
10812 return true;
10813}
10814
10815JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onerror, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
10816{
10817 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onerrorSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
10818}
10819
10820static inline JSValue jsDOMWindow_onfocusGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
10821{
10822 auto& vm = JSC::getVM(&lexicalGlobalObject);
10823 auto throwScope = DECLARE_THROW_SCOPE(vm);
10824 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10825 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10826 if (!shouldAllowAccess)
10827 return jsUndefined();
10828 return eventHandlerAttribute(thisObject.wrapped(), eventNames().focusEvent, worldForDOMObject(thisObject));
10829}
10830
10831JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onfocus, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
10832{
10833 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onfocusGetter>(*lexicalGlobalObject, thisValue, attributeName);
10834}
10835
10836static inline bool setJSDOMWindow_onfocusSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
10837{
10838 auto& vm = JSC::getVM(&lexicalGlobalObject);
10839 auto throwScope = DECLARE_THROW_SCOPE(vm);
10840 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10841 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10842 if (!shouldAllowAccess)
10843 return false;
10844 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().focusEvent, value);
10845 vm.heap.writeBarrier(&thisObject, value);
10846 ensureStillAliveHere(value);
10847
10848 return true;
10849}
10850
10851JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onfocus, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
10852{
10853 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onfocusSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
10854}
10855
10856static inline JSValue jsDOMWindow_oninputGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
10857{
10858 auto& vm = JSC::getVM(&lexicalGlobalObject);
10859 auto throwScope = DECLARE_THROW_SCOPE(vm);
10860 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10861 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10862 if (!shouldAllowAccess)
10863 return jsUndefined();
10864 return eventHandlerAttribute(thisObject.wrapped(), eventNames().inputEvent, worldForDOMObject(thisObject));
10865}
10866
10867JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_oninput, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
10868{
10869 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_oninputGetter>(*lexicalGlobalObject, thisValue, attributeName);
10870}
10871
10872static inline bool setJSDOMWindow_oninputSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
10873{
10874 auto& vm = JSC::getVM(&lexicalGlobalObject);
10875 auto throwScope = DECLARE_THROW_SCOPE(vm);
10876 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10877 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10878 if (!shouldAllowAccess)
10879 return false;
10880 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().inputEvent, value);
10881 vm.heap.writeBarrier(&thisObject, value);
10882 ensureStillAliveHere(value);
10883
10884 return true;
10885}
10886
10887JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_oninput, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
10888{
10889 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_oninputSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
10890}
10891
10892static inline JSValue jsDOMWindow_oninvalidGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
10893{
10894 auto& vm = JSC::getVM(&lexicalGlobalObject);
10895 auto throwScope = DECLARE_THROW_SCOPE(vm);
10896 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10897 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10898 if (!shouldAllowAccess)
10899 return jsUndefined();
10900 return eventHandlerAttribute(thisObject.wrapped(), eventNames().invalidEvent, worldForDOMObject(thisObject));
10901}
10902
10903JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_oninvalid, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
10904{
10905 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_oninvalidGetter>(*lexicalGlobalObject, thisValue, attributeName);
10906}
10907
10908static inline bool setJSDOMWindow_oninvalidSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
10909{
10910 auto& vm = JSC::getVM(&lexicalGlobalObject);
10911 auto throwScope = DECLARE_THROW_SCOPE(vm);
10912 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10913 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10914 if (!shouldAllowAccess)
10915 return false;
10916 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().invalidEvent, value);
10917 vm.heap.writeBarrier(&thisObject, value);
10918 ensureStillAliveHere(value);
10919
10920 return true;
10921}
10922
10923JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_oninvalid, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
10924{
10925 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_oninvalidSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
10926}
10927
10928static inline JSValue jsDOMWindow_onkeydownGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
10929{
10930 auto& vm = JSC::getVM(&lexicalGlobalObject);
10931 auto throwScope = DECLARE_THROW_SCOPE(vm);
10932 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10933 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10934 if (!shouldAllowAccess)
10935 return jsUndefined();
10936 return eventHandlerAttribute(thisObject.wrapped(), eventNames().keydownEvent, worldForDOMObject(thisObject));
10937}
10938
10939JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onkeydown, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
10940{
10941 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onkeydownGetter>(*lexicalGlobalObject, thisValue, attributeName);
10942}
10943
10944static inline bool setJSDOMWindow_onkeydownSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
10945{
10946 auto& vm = JSC::getVM(&lexicalGlobalObject);
10947 auto throwScope = DECLARE_THROW_SCOPE(vm);
10948 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10949 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10950 if (!shouldAllowAccess)
10951 return false;
10952 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().keydownEvent, value);
10953 vm.heap.writeBarrier(&thisObject, value);
10954 ensureStillAliveHere(value);
10955
10956 return true;
10957}
10958
10959JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onkeydown, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
10960{
10961 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onkeydownSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
10962}
10963
10964static inline JSValue jsDOMWindow_onkeypressGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
10965{
10966 auto& vm = JSC::getVM(&lexicalGlobalObject);
10967 auto throwScope = DECLARE_THROW_SCOPE(vm);
10968 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10969 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10970 if (!shouldAllowAccess)
10971 return jsUndefined();
10972 return eventHandlerAttribute(thisObject.wrapped(), eventNames().keypressEvent, worldForDOMObject(thisObject));
10973}
10974
10975JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onkeypress, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
10976{
10977 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onkeypressGetter>(*lexicalGlobalObject, thisValue, attributeName);
10978}
10979
10980static inline bool setJSDOMWindow_onkeypressSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
10981{
10982 auto& vm = JSC::getVM(&lexicalGlobalObject);
10983 auto throwScope = DECLARE_THROW_SCOPE(vm);
10984 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
10985 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
10986 if (!shouldAllowAccess)
10987 return false;
10988 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().keypressEvent, value);
10989 vm.heap.writeBarrier(&thisObject, value);
10990 ensureStillAliveHere(value);
10991
10992 return true;
10993}
10994
10995JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onkeypress, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
10996{
10997 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onkeypressSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
10998}
10999
11000static inline JSValue jsDOMWindow_onkeyupGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
11001{
11002 auto& vm = JSC::getVM(&lexicalGlobalObject);
11003 auto throwScope = DECLARE_THROW_SCOPE(vm);
11004 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11005 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11006 if (!shouldAllowAccess)
11007 return jsUndefined();
11008 return eventHandlerAttribute(thisObject.wrapped(), eventNames().keyupEvent, worldForDOMObject(thisObject));
11009}
11010
11011JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onkeyup, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
11012{
11013 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onkeyupGetter>(*lexicalGlobalObject, thisValue, attributeName);
11014}
11015
11016static inline bool setJSDOMWindow_onkeyupSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
11017{
11018 auto& vm = JSC::getVM(&lexicalGlobalObject);
11019 auto throwScope = DECLARE_THROW_SCOPE(vm);
11020 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11021 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11022 if (!shouldAllowAccess)
11023 return false;
11024 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().keyupEvent, value);
11025 vm.heap.writeBarrier(&thisObject, value);
11026 ensureStillAliveHere(value);
11027
11028 return true;
11029}
11030
11031JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onkeyup, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
11032{
11033 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onkeyupSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
11034}
11035
11036static inline JSValue jsDOMWindow_onloadGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
11037{
11038 auto& vm = JSC::getVM(&lexicalGlobalObject);
11039 auto throwScope = DECLARE_THROW_SCOPE(vm);
11040 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11041 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11042 if (!shouldAllowAccess)
11043 return jsUndefined();
11044 return eventHandlerAttribute(thisObject.wrapped(), eventNames().loadEvent, worldForDOMObject(thisObject));
11045}
11046
11047JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onload, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
11048{
11049 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onloadGetter>(*lexicalGlobalObject, thisValue, attributeName);
11050}
11051
11052static inline bool setJSDOMWindow_onloadSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
11053{
11054 auto& vm = JSC::getVM(&lexicalGlobalObject);
11055 auto throwScope = DECLARE_THROW_SCOPE(vm);
11056 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11057 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11058 if (!shouldAllowAccess)
11059 return false;
11060 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().loadEvent, value);
11061 vm.heap.writeBarrier(&thisObject, value);
11062 ensureStillAliveHere(value);
11063
11064 return true;
11065}
11066
11067JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onload, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
11068{
11069 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onloadSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
11070}
11071
11072static inline JSValue jsDOMWindow_onloadeddataGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
11073{
11074 auto& vm = JSC::getVM(&lexicalGlobalObject);
11075 auto throwScope = DECLARE_THROW_SCOPE(vm);
11076 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11077 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11078 if (!shouldAllowAccess)
11079 return jsUndefined();
11080 return eventHandlerAttribute(thisObject.wrapped(), eventNames().loadeddataEvent, worldForDOMObject(thisObject));
11081}
11082
11083JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onloadeddata, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
11084{
11085 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onloadeddataGetter>(*lexicalGlobalObject, thisValue, attributeName);
11086}
11087
11088static inline bool setJSDOMWindow_onloadeddataSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
11089{
11090 auto& vm = JSC::getVM(&lexicalGlobalObject);
11091 auto throwScope = DECLARE_THROW_SCOPE(vm);
11092 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11093 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11094 if (!shouldAllowAccess)
11095 return false;
11096 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().loadeddataEvent, value);
11097 vm.heap.writeBarrier(&thisObject, value);
11098 ensureStillAliveHere(value);
11099
11100 return true;
11101}
11102
11103JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onloadeddata, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
11104{
11105 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onloadeddataSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
11106}
11107
11108static inline JSValue jsDOMWindow_onloadedmetadataGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
11109{
11110 auto& vm = JSC::getVM(&lexicalGlobalObject);
11111 auto throwScope = DECLARE_THROW_SCOPE(vm);
11112 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11113 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11114 if (!shouldAllowAccess)
11115 return jsUndefined();
11116 return eventHandlerAttribute(thisObject.wrapped(), eventNames().loadedmetadataEvent, worldForDOMObject(thisObject));
11117}
11118
11119JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onloadedmetadata, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
11120{
11121 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onloadedmetadataGetter>(*lexicalGlobalObject, thisValue, attributeName);
11122}
11123
11124static inline bool setJSDOMWindow_onloadedmetadataSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
11125{
11126 auto& vm = JSC::getVM(&lexicalGlobalObject);
11127 auto throwScope = DECLARE_THROW_SCOPE(vm);
11128 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11129 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11130 if (!shouldAllowAccess)
11131 return false;
11132 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().loadedmetadataEvent, value);
11133 vm.heap.writeBarrier(&thisObject, value);
11134 ensureStillAliveHere(value);
11135
11136 return true;
11137}
11138
11139JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onloadedmetadata, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
11140{
11141 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onloadedmetadataSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
11142}
11143
11144static inline JSValue jsDOMWindow_onloadstartGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
11145{
11146 auto& vm = JSC::getVM(&lexicalGlobalObject);
11147 auto throwScope = DECLARE_THROW_SCOPE(vm);
11148 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11149 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11150 if (!shouldAllowAccess)
11151 return jsUndefined();
11152 return eventHandlerAttribute(thisObject.wrapped(), eventNames().loadstartEvent, worldForDOMObject(thisObject));
11153}
11154
11155JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onloadstart, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
11156{
11157 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onloadstartGetter>(*lexicalGlobalObject, thisValue, attributeName);
11158}
11159
11160static inline bool setJSDOMWindow_onloadstartSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
11161{
11162 auto& vm = JSC::getVM(&lexicalGlobalObject);
11163 auto throwScope = DECLARE_THROW_SCOPE(vm);
11164 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11165 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11166 if (!shouldAllowAccess)
11167 return false;
11168 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().loadstartEvent, value);
11169 vm.heap.writeBarrier(&thisObject, value);
11170 ensureStillAliveHere(value);
11171
11172 return true;
11173}
11174
11175JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onloadstart, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
11176{
11177 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onloadstartSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
11178}
11179
11180static inline JSValue jsDOMWindow_onmousedownGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
11181{
11182 auto& vm = JSC::getVM(&lexicalGlobalObject);
11183 auto throwScope = DECLARE_THROW_SCOPE(vm);
11184 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11185 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11186 if (!shouldAllowAccess)
11187 return jsUndefined();
11188 return eventHandlerAttribute(thisObject.wrapped(), eventNames().mousedownEvent, worldForDOMObject(thisObject));
11189}
11190
11191JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onmousedown, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
11192{
11193 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onmousedownGetter>(*lexicalGlobalObject, thisValue, attributeName);
11194}
11195
11196static inline bool setJSDOMWindow_onmousedownSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
11197{
11198 auto& vm = JSC::getVM(&lexicalGlobalObject);
11199 auto throwScope = DECLARE_THROW_SCOPE(vm);
11200 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11201 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11202 if (!shouldAllowAccess)
11203 return false;
11204 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().mousedownEvent, value);
11205 vm.heap.writeBarrier(&thisObject, value);
11206 ensureStillAliveHere(value);
11207
11208 return true;
11209}
11210
11211JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onmousedown, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
11212{
11213 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onmousedownSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
11214}
11215
11216static inline JSValue jsDOMWindow_onmouseenterGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
11217{
11218 auto& vm = JSC::getVM(&lexicalGlobalObject);
11219 auto throwScope = DECLARE_THROW_SCOPE(vm);
11220 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11221 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11222 if (!shouldAllowAccess)
11223 return jsUndefined();
11224 return eventHandlerAttribute(thisObject.wrapped(), eventNames().mouseenterEvent, worldForDOMObject(thisObject));
11225}
11226
11227JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onmouseenter, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
11228{
11229 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onmouseenterGetter, CastedThisErrorBehavior::ReturnEarly>(*lexicalGlobalObject, thisValue, attributeName);
11230}
11231
11232static inline bool setJSDOMWindow_onmouseenterSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
11233{
11234 auto& vm = JSC::getVM(&lexicalGlobalObject);
11235 auto throwScope = DECLARE_THROW_SCOPE(vm);
11236 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11237 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11238 if (!shouldAllowAccess)
11239 return false;
11240 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().mouseenterEvent, value);
11241 vm.heap.writeBarrier(&thisObject, value);
11242 ensureStillAliveHere(value);
11243
11244 return true;
11245}
11246
11247JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onmouseenter, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
11248{
11249 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onmouseenterSetter, CastedThisErrorBehavior::ReturnEarly>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
11250}
11251
11252static inline JSValue jsDOMWindow_onmouseleaveGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
11253{
11254 auto& vm = JSC::getVM(&lexicalGlobalObject);
11255 auto throwScope = DECLARE_THROW_SCOPE(vm);
11256 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11257 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11258 if (!shouldAllowAccess)
11259 return jsUndefined();
11260 return eventHandlerAttribute(thisObject.wrapped(), eventNames().mouseleaveEvent, worldForDOMObject(thisObject));
11261}
11262
11263JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onmouseleave, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
11264{
11265 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onmouseleaveGetter, CastedThisErrorBehavior::ReturnEarly>(*lexicalGlobalObject, thisValue, attributeName);
11266}
11267
11268static inline bool setJSDOMWindow_onmouseleaveSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
11269{
11270 auto& vm = JSC::getVM(&lexicalGlobalObject);
11271 auto throwScope = DECLARE_THROW_SCOPE(vm);
11272 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11273 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11274 if (!shouldAllowAccess)
11275 return false;
11276 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().mouseleaveEvent, value);
11277 vm.heap.writeBarrier(&thisObject, value);
11278 ensureStillAliveHere(value);
11279
11280 return true;
11281}
11282
11283JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onmouseleave, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
11284{
11285 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onmouseleaveSetter, CastedThisErrorBehavior::ReturnEarly>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
11286}
11287
11288static inline JSValue jsDOMWindow_onmousemoveGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
11289{
11290 auto& vm = JSC::getVM(&lexicalGlobalObject);
11291 auto throwScope = DECLARE_THROW_SCOPE(vm);
11292 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11293 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11294 if (!shouldAllowAccess)
11295 return jsUndefined();
11296 return eventHandlerAttribute(thisObject.wrapped(), eventNames().mousemoveEvent, worldForDOMObject(thisObject));
11297}
11298
11299JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onmousemove, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
11300{
11301 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onmousemoveGetter>(*lexicalGlobalObject, thisValue, attributeName);
11302}
11303
11304static inline bool setJSDOMWindow_onmousemoveSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
11305{
11306 auto& vm = JSC::getVM(&lexicalGlobalObject);
11307 auto throwScope = DECLARE_THROW_SCOPE(vm);
11308 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11309 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11310 if (!shouldAllowAccess)
11311 return false;
11312 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().mousemoveEvent, value);
11313 vm.heap.writeBarrier(&thisObject, value);
11314 ensureStillAliveHere(value);
11315
11316 return true;
11317}
11318
11319JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onmousemove, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
11320{
11321 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onmousemoveSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
11322}
11323
11324static inline JSValue jsDOMWindow_onmouseoutGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
11325{
11326 auto& vm = JSC::getVM(&lexicalGlobalObject);
11327 auto throwScope = DECLARE_THROW_SCOPE(vm);
11328 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11329 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11330 if (!shouldAllowAccess)
11331 return jsUndefined();
11332 return eventHandlerAttribute(thisObject.wrapped(), eventNames().mouseoutEvent, worldForDOMObject(thisObject));
11333}
11334
11335JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onmouseout, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
11336{
11337 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onmouseoutGetter>(*lexicalGlobalObject, thisValue, attributeName);
11338}
11339
11340static inline bool setJSDOMWindow_onmouseoutSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
11341{
11342 auto& vm = JSC::getVM(&lexicalGlobalObject);
11343 auto throwScope = DECLARE_THROW_SCOPE(vm);
11344 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11345 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11346 if (!shouldAllowAccess)
11347 return false;
11348 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().mouseoutEvent, value);
11349 vm.heap.writeBarrier(&thisObject, value);
11350 ensureStillAliveHere(value);
11351
11352 return true;
11353}
11354
11355JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onmouseout, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
11356{
11357 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onmouseoutSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
11358}
11359
11360static inline JSValue jsDOMWindow_onmouseoverGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
11361{
11362 auto& vm = JSC::getVM(&lexicalGlobalObject);
11363 auto throwScope = DECLARE_THROW_SCOPE(vm);
11364 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11365 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11366 if (!shouldAllowAccess)
11367 return jsUndefined();
11368 return eventHandlerAttribute(thisObject.wrapped(), eventNames().mouseoverEvent, worldForDOMObject(thisObject));
11369}
11370
11371JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onmouseover, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
11372{
11373 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onmouseoverGetter>(*lexicalGlobalObject, thisValue, attributeName);
11374}
11375
11376static inline bool setJSDOMWindow_onmouseoverSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
11377{
11378 auto& vm = JSC::getVM(&lexicalGlobalObject);
11379 auto throwScope = DECLARE_THROW_SCOPE(vm);
11380 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11381 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11382 if (!shouldAllowAccess)
11383 return false;
11384 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().mouseoverEvent, value);
11385 vm.heap.writeBarrier(&thisObject, value);
11386 ensureStillAliveHere(value);
11387
11388 return true;
11389}
11390
11391JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onmouseover, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
11392{
11393 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onmouseoverSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
11394}
11395
11396static inline JSValue jsDOMWindow_onmouseupGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
11397{
11398 auto& vm = JSC::getVM(&lexicalGlobalObject);
11399 auto throwScope = DECLARE_THROW_SCOPE(vm);
11400 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11401 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11402 if (!shouldAllowAccess)
11403 return jsUndefined();
11404 return eventHandlerAttribute(thisObject.wrapped(), eventNames().mouseupEvent, worldForDOMObject(thisObject));
11405}
11406
11407JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onmouseup, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
11408{
11409 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onmouseupGetter>(*lexicalGlobalObject, thisValue, attributeName);
11410}
11411
11412static inline bool setJSDOMWindow_onmouseupSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
11413{
11414 auto& vm = JSC::getVM(&lexicalGlobalObject);
11415 auto throwScope = DECLARE_THROW_SCOPE(vm);
11416 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11417 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11418 if (!shouldAllowAccess)
11419 return false;
11420 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().mouseupEvent, value);
11421 vm.heap.writeBarrier(&thisObject, value);
11422 ensureStillAliveHere(value);
11423
11424 return true;
11425}
11426
11427JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onmouseup, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
11428{
11429 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onmouseupSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
11430}
11431
11432static inline JSValue jsDOMWindow_onpauseGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
11433{
11434 auto& vm = JSC::getVM(&lexicalGlobalObject);
11435 auto throwScope = DECLARE_THROW_SCOPE(vm);
11436 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11437 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11438 if (!shouldAllowAccess)
11439 return jsUndefined();
11440 return eventHandlerAttribute(thisObject.wrapped(), eventNames().pauseEvent, worldForDOMObject(thisObject));
11441}
11442
11443JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onpause, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
11444{
11445 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onpauseGetter>(*lexicalGlobalObject, thisValue, attributeName);
11446}
11447
11448static inline bool setJSDOMWindow_onpauseSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
11449{
11450 auto& vm = JSC::getVM(&lexicalGlobalObject);
11451 auto throwScope = DECLARE_THROW_SCOPE(vm);
11452 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11453 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11454 if (!shouldAllowAccess)
11455 return false;
11456 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().pauseEvent, value);
11457 vm.heap.writeBarrier(&thisObject, value);
11458 ensureStillAliveHere(value);
11459
11460 return true;
11461}
11462
11463JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onpause, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
11464{
11465 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onpauseSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
11466}
11467
11468static inline JSValue jsDOMWindow_onplayGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
11469{
11470 auto& vm = JSC::getVM(&lexicalGlobalObject);
11471 auto throwScope = DECLARE_THROW_SCOPE(vm);
11472 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11473 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11474 if (!shouldAllowAccess)
11475 return jsUndefined();
11476 return eventHandlerAttribute(thisObject.wrapped(), eventNames().playEvent, worldForDOMObject(thisObject));
11477}
11478
11479JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onplay, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
11480{
11481 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onplayGetter>(*lexicalGlobalObject, thisValue, attributeName);
11482}
11483
11484static inline bool setJSDOMWindow_onplaySetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
11485{
11486 auto& vm = JSC::getVM(&lexicalGlobalObject);
11487 auto throwScope = DECLARE_THROW_SCOPE(vm);
11488 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11489 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11490 if (!shouldAllowAccess)
11491 return false;
11492 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().playEvent, value);
11493 vm.heap.writeBarrier(&thisObject, value);
11494 ensureStillAliveHere(value);
11495
11496 return true;
11497}
11498
11499JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onplay, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
11500{
11501 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onplaySetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
11502}
11503
11504static inline JSValue jsDOMWindow_onplayingGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
11505{
11506 auto& vm = JSC::getVM(&lexicalGlobalObject);
11507 auto throwScope = DECLARE_THROW_SCOPE(vm);
11508 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11509 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11510 if (!shouldAllowAccess)
11511 return jsUndefined();
11512 return eventHandlerAttribute(thisObject.wrapped(), eventNames().playingEvent, worldForDOMObject(thisObject));
11513}
11514
11515JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onplaying, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
11516{
11517 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onplayingGetter>(*lexicalGlobalObject, thisValue, attributeName);
11518}
11519
11520static inline bool setJSDOMWindow_onplayingSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
11521{
11522 auto& vm = JSC::getVM(&lexicalGlobalObject);
11523 auto throwScope = DECLARE_THROW_SCOPE(vm);
11524 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11525 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11526 if (!shouldAllowAccess)
11527 return false;
11528 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().playingEvent, value);
11529 vm.heap.writeBarrier(&thisObject, value);
11530 ensureStillAliveHere(value);
11531
11532 return true;
11533}
11534
11535JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onplaying, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
11536{
11537 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onplayingSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
11538}
11539
11540static inline JSValue jsDOMWindow_onprogressGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
11541{
11542 auto& vm = JSC::getVM(&lexicalGlobalObject);
11543 auto throwScope = DECLARE_THROW_SCOPE(vm);
11544 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11545 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11546 if (!shouldAllowAccess)
11547 return jsUndefined();
11548 return eventHandlerAttribute(thisObject.wrapped(), eventNames().progressEvent, worldForDOMObject(thisObject));
11549}
11550
11551JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onprogress, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
11552{
11553 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onprogressGetter>(*lexicalGlobalObject, thisValue, attributeName);
11554}
11555
11556static inline bool setJSDOMWindow_onprogressSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
11557{
11558 auto& vm = JSC::getVM(&lexicalGlobalObject);
11559 auto throwScope = DECLARE_THROW_SCOPE(vm);
11560 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11561 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11562 if (!shouldAllowAccess)
11563 return false;
11564 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().progressEvent, value);
11565 vm.heap.writeBarrier(&thisObject, value);
11566 ensureStillAliveHere(value);
11567
11568 return true;
11569}
11570
11571JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onprogress, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
11572{
11573 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onprogressSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
11574}
11575
11576static inline JSValue jsDOMWindow_onratechangeGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
11577{
11578 auto& vm = JSC::getVM(&lexicalGlobalObject);
11579 auto throwScope = DECLARE_THROW_SCOPE(vm);
11580 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11581 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11582 if (!shouldAllowAccess)
11583 return jsUndefined();
11584 return eventHandlerAttribute(thisObject.wrapped(), eventNames().ratechangeEvent, worldForDOMObject(thisObject));
11585}
11586
11587JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onratechange, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
11588{
11589 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onratechangeGetter>(*lexicalGlobalObject, thisValue, attributeName);
11590}
11591
11592static inline bool setJSDOMWindow_onratechangeSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
11593{
11594 auto& vm = JSC::getVM(&lexicalGlobalObject);
11595 auto throwScope = DECLARE_THROW_SCOPE(vm);
11596 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11597 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11598 if (!shouldAllowAccess)
11599 return false;
11600 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().ratechangeEvent, value);
11601 vm.heap.writeBarrier(&thisObject, value);
11602 ensureStillAliveHere(value);
11603
11604 return true;
11605}
11606
11607JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onratechange, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
11608{
11609 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onratechangeSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
11610}
11611
11612static inline JSValue jsDOMWindow_onresetGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
11613{
11614 auto& vm = JSC::getVM(&lexicalGlobalObject);
11615 auto throwScope = DECLARE_THROW_SCOPE(vm);
11616 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11617 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11618 if (!shouldAllowAccess)
11619 return jsUndefined();
11620 return eventHandlerAttribute(thisObject.wrapped(), eventNames().resetEvent, worldForDOMObject(thisObject));
11621}
11622
11623JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onreset, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
11624{
11625 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onresetGetter>(*lexicalGlobalObject, thisValue, attributeName);
11626}
11627
11628static inline bool setJSDOMWindow_onresetSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
11629{
11630 auto& vm = JSC::getVM(&lexicalGlobalObject);
11631 auto throwScope = DECLARE_THROW_SCOPE(vm);
11632 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11633 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11634 if (!shouldAllowAccess)
11635 return false;
11636 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().resetEvent, value);
11637 vm.heap.writeBarrier(&thisObject, value);
11638 ensureStillAliveHere(value);
11639
11640 return true;
11641}
11642
11643JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onreset, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
11644{
11645 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onresetSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
11646}
11647
11648static inline JSValue jsDOMWindow_onresizeGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
11649{
11650 auto& vm = JSC::getVM(&lexicalGlobalObject);
11651 auto throwScope = DECLARE_THROW_SCOPE(vm);
11652 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11653 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11654 if (!shouldAllowAccess)
11655 return jsUndefined();
11656 return eventHandlerAttribute(thisObject.wrapped(), eventNames().resizeEvent, worldForDOMObject(thisObject));
11657}
11658
11659JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onresize, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
11660{
11661 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onresizeGetter>(*lexicalGlobalObject, thisValue, attributeName);
11662}
11663
11664static inline bool setJSDOMWindow_onresizeSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
11665{
11666 auto& vm = JSC::getVM(&lexicalGlobalObject);
11667 auto throwScope = DECLARE_THROW_SCOPE(vm);
11668 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11669 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11670 if (!shouldAllowAccess)
11671 return false;
11672 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().resizeEvent, value);
11673 vm.heap.writeBarrier(&thisObject, value);
11674 ensureStillAliveHere(value);
11675
11676 return true;
11677}
11678
11679JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onresize, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
11680{
11681 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onresizeSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
11682}
11683
11684static inline JSValue jsDOMWindow_onscrollGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
11685{
11686 auto& vm = JSC::getVM(&lexicalGlobalObject);
11687 auto throwScope = DECLARE_THROW_SCOPE(vm);
11688 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11689 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11690 if (!shouldAllowAccess)
11691 return jsUndefined();
11692 return eventHandlerAttribute(thisObject.wrapped(), eventNames().scrollEvent, worldForDOMObject(thisObject));
11693}
11694
11695JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onscroll, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
11696{
11697 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onscrollGetter>(*lexicalGlobalObject, thisValue, attributeName);
11698}
11699
11700static inline bool setJSDOMWindow_onscrollSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
11701{
11702 auto& vm = JSC::getVM(&lexicalGlobalObject);
11703 auto throwScope = DECLARE_THROW_SCOPE(vm);
11704 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11705 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11706 if (!shouldAllowAccess)
11707 return false;
11708 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().scrollEvent, value);
11709 vm.heap.writeBarrier(&thisObject, value);
11710 ensureStillAliveHere(value);
11711
11712 return true;
11713}
11714
11715JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onscroll, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
11716{
11717 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onscrollSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
11718}
11719
11720static inline JSValue jsDOMWindow_onseekedGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
11721{
11722 auto& vm = JSC::getVM(&lexicalGlobalObject);
11723 auto throwScope = DECLARE_THROW_SCOPE(vm);
11724 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11725 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11726 if (!shouldAllowAccess)
11727 return jsUndefined();
11728 return eventHandlerAttribute(thisObject.wrapped(), eventNames().seekedEvent, worldForDOMObject(thisObject));
11729}
11730
11731JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onseeked, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
11732{
11733 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onseekedGetter>(*lexicalGlobalObject, thisValue, attributeName);
11734}
11735
11736static inline bool setJSDOMWindow_onseekedSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
11737{
11738 auto& vm = JSC::getVM(&lexicalGlobalObject);
11739 auto throwScope = DECLARE_THROW_SCOPE(vm);
11740 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11741 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11742 if (!shouldAllowAccess)
11743 return false;
11744 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().seekedEvent, value);
11745 vm.heap.writeBarrier(&thisObject, value);
11746 ensureStillAliveHere(value);
11747
11748 return true;
11749}
11750
11751JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onseeked, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
11752{
11753 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onseekedSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
11754}
11755
11756static inline JSValue jsDOMWindow_onseekingGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
11757{
11758 auto& vm = JSC::getVM(&lexicalGlobalObject);
11759 auto throwScope = DECLARE_THROW_SCOPE(vm);
11760 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11761 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11762 if (!shouldAllowAccess)
11763 return jsUndefined();
11764 return eventHandlerAttribute(thisObject.wrapped(), eventNames().seekingEvent, worldForDOMObject(thisObject));
11765}
11766
11767JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onseeking, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
11768{
11769 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onseekingGetter>(*lexicalGlobalObject, thisValue, attributeName);
11770}
11771
11772static inline bool setJSDOMWindow_onseekingSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
11773{
11774 auto& vm = JSC::getVM(&lexicalGlobalObject);
11775 auto throwScope = DECLARE_THROW_SCOPE(vm);
11776 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11777 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11778 if (!shouldAllowAccess)
11779 return false;
11780 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().seekingEvent, value);
11781 vm.heap.writeBarrier(&thisObject, value);
11782 ensureStillAliveHere(value);
11783
11784 return true;
11785}
11786
11787JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onseeking, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
11788{
11789 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onseekingSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
11790}
11791
11792static inline JSValue jsDOMWindow_onselectGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
11793{
11794 auto& vm = JSC::getVM(&lexicalGlobalObject);
11795 auto throwScope = DECLARE_THROW_SCOPE(vm);
11796 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11797 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11798 if (!shouldAllowAccess)
11799 return jsUndefined();
11800 return eventHandlerAttribute(thisObject.wrapped(), eventNames().selectEvent, worldForDOMObject(thisObject));
11801}
11802
11803JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onselect, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
11804{
11805 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onselectGetter>(*lexicalGlobalObject, thisValue, attributeName);
11806}
11807
11808static inline bool setJSDOMWindow_onselectSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
11809{
11810 auto& vm = JSC::getVM(&lexicalGlobalObject);
11811 auto throwScope = DECLARE_THROW_SCOPE(vm);
11812 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11813 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11814 if (!shouldAllowAccess)
11815 return false;
11816 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().selectEvent, value);
11817 vm.heap.writeBarrier(&thisObject, value);
11818 ensureStillAliveHere(value);
11819
11820 return true;
11821}
11822
11823JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onselect, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
11824{
11825 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onselectSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
11826}
11827
11828static inline JSValue jsDOMWindow_onslotchangeGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
11829{
11830 auto& vm = JSC::getVM(&lexicalGlobalObject);
11831 auto throwScope = DECLARE_THROW_SCOPE(vm);
11832 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11833 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11834 if (!shouldAllowAccess)
11835 return jsUndefined();
11836 return eventHandlerAttribute(thisObject.wrapped(), eventNames().slotchangeEvent, worldForDOMObject(thisObject));
11837}
11838
11839JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onslotchange, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
11840{
11841 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onslotchangeGetter>(*lexicalGlobalObject, thisValue, attributeName);
11842}
11843
11844static inline bool setJSDOMWindow_onslotchangeSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
11845{
11846 auto& vm = JSC::getVM(&lexicalGlobalObject);
11847 auto throwScope = DECLARE_THROW_SCOPE(vm);
11848 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11849 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11850 if (!shouldAllowAccess)
11851 return false;
11852 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().slotchangeEvent, value);
11853 vm.heap.writeBarrier(&thisObject, value);
11854 ensureStillAliveHere(value);
11855
11856 return true;
11857}
11858
11859JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onslotchange, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
11860{
11861 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onslotchangeSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
11862}
11863
11864static inline JSValue jsDOMWindow_onstalledGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
11865{
11866 auto& vm = JSC::getVM(&lexicalGlobalObject);
11867 auto throwScope = DECLARE_THROW_SCOPE(vm);
11868 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11869 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11870 if (!shouldAllowAccess)
11871 return jsUndefined();
11872 return eventHandlerAttribute(thisObject.wrapped(), eventNames().stalledEvent, worldForDOMObject(thisObject));
11873}
11874
11875JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onstalled, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
11876{
11877 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onstalledGetter>(*lexicalGlobalObject, thisValue, attributeName);
11878}
11879
11880static inline bool setJSDOMWindow_onstalledSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
11881{
11882 auto& vm = JSC::getVM(&lexicalGlobalObject);
11883 auto throwScope = DECLARE_THROW_SCOPE(vm);
11884 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11885 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11886 if (!shouldAllowAccess)
11887 return false;
11888 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().stalledEvent, value);
11889 vm.heap.writeBarrier(&thisObject, value);
11890 ensureStillAliveHere(value);
11891
11892 return true;
11893}
11894
11895JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onstalled, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
11896{
11897 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onstalledSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
11898}
11899
11900static inline JSValue jsDOMWindow_onsubmitGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
11901{
11902 auto& vm = JSC::getVM(&lexicalGlobalObject);
11903 auto throwScope = DECLARE_THROW_SCOPE(vm);
11904 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11905 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11906 if (!shouldAllowAccess)
11907 return jsUndefined();
11908 return eventHandlerAttribute(thisObject.wrapped(), eventNames().submitEvent, worldForDOMObject(thisObject));
11909}
11910
11911JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onsubmit, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
11912{
11913 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onsubmitGetter>(*lexicalGlobalObject, thisValue, attributeName);
11914}
11915
11916static inline bool setJSDOMWindow_onsubmitSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
11917{
11918 auto& vm = JSC::getVM(&lexicalGlobalObject);
11919 auto throwScope = DECLARE_THROW_SCOPE(vm);
11920 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11921 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11922 if (!shouldAllowAccess)
11923 return false;
11924 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().submitEvent, value);
11925 vm.heap.writeBarrier(&thisObject, value);
11926 ensureStillAliveHere(value);
11927
11928 return true;
11929}
11930
11931JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onsubmit, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
11932{
11933 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onsubmitSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
11934}
11935
11936static inline JSValue jsDOMWindow_onsuspendGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
11937{
11938 auto& vm = JSC::getVM(&lexicalGlobalObject);
11939 auto throwScope = DECLARE_THROW_SCOPE(vm);
11940 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11941 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11942 if (!shouldAllowAccess)
11943 return jsUndefined();
11944 return eventHandlerAttribute(thisObject.wrapped(), eventNames().suspendEvent, worldForDOMObject(thisObject));
11945}
11946
11947JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onsuspend, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
11948{
11949 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onsuspendGetter>(*lexicalGlobalObject, thisValue, attributeName);
11950}
11951
11952static inline bool setJSDOMWindow_onsuspendSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
11953{
11954 auto& vm = JSC::getVM(&lexicalGlobalObject);
11955 auto throwScope = DECLARE_THROW_SCOPE(vm);
11956 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11957 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11958 if (!shouldAllowAccess)
11959 return false;
11960 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().suspendEvent, value);
11961 vm.heap.writeBarrier(&thisObject, value);
11962 ensureStillAliveHere(value);
11963
11964 return true;
11965}
11966
11967JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onsuspend, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
11968{
11969 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onsuspendSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
11970}
11971
11972static inline JSValue jsDOMWindow_ontimeupdateGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
11973{
11974 auto& vm = JSC::getVM(&lexicalGlobalObject);
11975 auto throwScope = DECLARE_THROW_SCOPE(vm);
11976 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11977 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11978 if (!shouldAllowAccess)
11979 return jsUndefined();
11980 return eventHandlerAttribute(thisObject.wrapped(), eventNames().timeupdateEvent, worldForDOMObject(thisObject));
11981}
11982
11983JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ontimeupdate, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
11984{
11985 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ontimeupdateGetter>(*lexicalGlobalObject, thisValue, attributeName);
11986}
11987
11988static inline bool setJSDOMWindow_ontimeupdateSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
11989{
11990 auto& vm = JSC::getVM(&lexicalGlobalObject);
11991 auto throwScope = DECLARE_THROW_SCOPE(vm);
11992 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
11993 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
11994 if (!shouldAllowAccess)
11995 return false;
11996 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().timeupdateEvent, value);
11997 vm.heap.writeBarrier(&thisObject, value);
11998 ensureStillAliveHere(value);
11999
12000 return true;
12001}
12002
12003JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_ontimeupdate, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
12004{
12005 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_ontimeupdateSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
12006}
12007
12008static inline JSValue jsDOMWindow_ontoggleGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
12009{
12010 auto& vm = JSC::getVM(&lexicalGlobalObject);
12011 auto throwScope = DECLARE_THROW_SCOPE(vm);
12012 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12013 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12014 if (!shouldAllowAccess)
12015 return jsUndefined();
12016 return eventHandlerAttribute(thisObject.wrapped(), eventNames().toggleEvent, worldForDOMObject(thisObject));
12017}
12018
12019JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ontoggle, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
12020{
12021 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ontoggleGetter>(*lexicalGlobalObject, thisValue, attributeName);
12022}
12023
12024static inline bool setJSDOMWindow_ontoggleSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
12025{
12026 auto& vm = JSC::getVM(&lexicalGlobalObject);
12027 auto throwScope = DECLARE_THROW_SCOPE(vm);
12028 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12029 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12030 if (!shouldAllowAccess)
12031 return false;
12032 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().toggleEvent, value);
12033 vm.heap.writeBarrier(&thisObject, value);
12034 ensureStillAliveHere(value);
12035
12036 return true;
12037}
12038
12039JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_ontoggle, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
12040{
12041 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_ontoggleSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
12042}
12043
12044static inline JSValue jsDOMWindow_onvolumechangeGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
12045{
12046 auto& vm = JSC::getVM(&lexicalGlobalObject);
12047 auto throwScope = DECLARE_THROW_SCOPE(vm);
12048 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12049 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12050 if (!shouldAllowAccess)
12051 return jsUndefined();
12052 return eventHandlerAttribute(thisObject.wrapped(), eventNames().volumechangeEvent, worldForDOMObject(thisObject));
12053}
12054
12055JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onvolumechange, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
12056{
12057 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onvolumechangeGetter>(*lexicalGlobalObject, thisValue, attributeName);
12058}
12059
12060static inline bool setJSDOMWindow_onvolumechangeSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
12061{
12062 auto& vm = JSC::getVM(&lexicalGlobalObject);
12063 auto throwScope = DECLARE_THROW_SCOPE(vm);
12064 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12065 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12066 if (!shouldAllowAccess)
12067 return false;
12068 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().volumechangeEvent, value);
12069 vm.heap.writeBarrier(&thisObject, value);
12070 ensureStillAliveHere(value);
12071
12072 return true;
12073}
12074
12075JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onvolumechange, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
12076{
12077 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onvolumechangeSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
12078}
12079
12080static inline JSValue jsDOMWindow_onwaitingGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
12081{
12082 auto& vm = JSC::getVM(&lexicalGlobalObject);
12083 auto throwScope = DECLARE_THROW_SCOPE(vm);
12084 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12085 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12086 if (!shouldAllowAccess)
12087 return jsUndefined();
12088 return eventHandlerAttribute(thisObject.wrapped(), eventNames().waitingEvent, worldForDOMObject(thisObject));
12089}
12090
12091JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onwaiting, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
12092{
12093 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onwaitingGetter>(*lexicalGlobalObject, thisValue, attributeName);
12094}
12095
12096static inline bool setJSDOMWindow_onwaitingSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
12097{
12098 auto& vm = JSC::getVM(&lexicalGlobalObject);
12099 auto throwScope = DECLARE_THROW_SCOPE(vm);
12100 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12101 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12102 if (!shouldAllowAccess)
12103 return false;
12104 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().waitingEvent, value);
12105 vm.heap.writeBarrier(&thisObject, value);
12106 ensureStillAliveHere(value);
12107
12108 return true;
12109}
12110
12111JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onwaiting, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
12112{
12113 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onwaitingSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
12114}
12115
12116static inline JSValue jsDOMWindow_onwebkitanimationendGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
12117{
12118 auto& vm = JSC::getVM(&lexicalGlobalObject);
12119 auto throwScope = DECLARE_THROW_SCOPE(vm);
12120 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12121 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12122 if (!shouldAllowAccess)
12123 return jsUndefined();
12124 return eventHandlerAttribute(thisObject.wrapped(), eventNames().webkitAnimationEndEvent, worldForDOMObject(thisObject));
12125}
12126
12127JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onwebkitanimationend, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
12128{
12129 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onwebkitanimationendGetter>(*lexicalGlobalObject, thisValue, attributeName);
12130}
12131
12132static inline bool setJSDOMWindow_onwebkitanimationendSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
12133{
12134 auto& vm = JSC::getVM(&lexicalGlobalObject);
12135 auto throwScope = DECLARE_THROW_SCOPE(vm);
12136 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12137 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12138 if (!shouldAllowAccess)
12139 return false;
12140 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().webkitAnimationEndEvent, value);
12141 vm.heap.writeBarrier(&thisObject, value);
12142 ensureStillAliveHere(value);
12143
12144 return true;
12145}
12146
12147JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onwebkitanimationend, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
12148{
12149 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onwebkitanimationendSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
12150}
12151
12152static inline JSValue jsDOMWindow_onwebkitanimationiterationGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
12153{
12154 auto& vm = JSC::getVM(&lexicalGlobalObject);
12155 auto throwScope = DECLARE_THROW_SCOPE(vm);
12156 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12157 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12158 if (!shouldAllowAccess)
12159 return jsUndefined();
12160 return eventHandlerAttribute(thisObject.wrapped(), eventNames().webkitAnimationIterationEvent, worldForDOMObject(thisObject));
12161}
12162
12163JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onwebkitanimationiteration, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
12164{
12165 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onwebkitanimationiterationGetter>(*lexicalGlobalObject, thisValue, attributeName);
12166}
12167
12168static inline bool setJSDOMWindow_onwebkitanimationiterationSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
12169{
12170 auto& vm = JSC::getVM(&lexicalGlobalObject);
12171 auto throwScope = DECLARE_THROW_SCOPE(vm);
12172 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12173 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12174 if (!shouldAllowAccess)
12175 return false;
12176 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().webkitAnimationIterationEvent, value);
12177 vm.heap.writeBarrier(&thisObject, value);
12178 ensureStillAliveHere(value);
12179
12180 return true;
12181}
12182
12183JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onwebkitanimationiteration, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
12184{
12185 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onwebkitanimationiterationSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
12186}
12187
12188static inline JSValue jsDOMWindow_onwebkitanimationstartGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
12189{
12190 auto& vm = JSC::getVM(&lexicalGlobalObject);
12191 auto throwScope = DECLARE_THROW_SCOPE(vm);
12192 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12193 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12194 if (!shouldAllowAccess)
12195 return jsUndefined();
12196 return eventHandlerAttribute(thisObject.wrapped(), eventNames().webkitAnimationStartEvent, worldForDOMObject(thisObject));
12197}
12198
12199JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onwebkitanimationstart, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
12200{
12201 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onwebkitanimationstartGetter>(*lexicalGlobalObject, thisValue, attributeName);
12202}
12203
12204static inline bool setJSDOMWindow_onwebkitanimationstartSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
12205{
12206 auto& vm = JSC::getVM(&lexicalGlobalObject);
12207 auto throwScope = DECLARE_THROW_SCOPE(vm);
12208 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12209 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12210 if (!shouldAllowAccess)
12211 return false;
12212 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().webkitAnimationStartEvent, value);
12213 vm.heap.writeBarrier(&thisObject, value);
12214 ensureStillAliveHere(value);
12215
12216 return true;
12217}
12218
12219JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onwebkitanimationstart, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
12220{
12221 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onwebkitanimationstartSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
12222}
12223
12224static inline JSValue jsDOMWindow_onwebkittransitionendGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
12225{
12226 auto& vm = JSC::getVM(&lexicalGlobalObject);
12227 auto throwScope = DECLARE_THROW_SCOPE(vm);
12228 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12229 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12230 if (!shouldAllowAccess)
12231 return jsUndefined();
12232 return eventHandlerAttribute(thisObject.wrapped(), eventNames().webkitTransitionEndEvent, worldForDOMObject(thisObject));
12233}
12234
12235JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onwebkittransitionend, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
12236{
12237 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onwebkittransitionendGetter>(*lexicalGlobalObject, thisValue, attributeName);
12238}
12239
12240static inline bool setJSDOMWindow_onwebkittransitionendSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
12241{
12242 auto& vm = JSC::getVM(&lexicalGlobalObject);
12243 auto throwScope = DECLARE_THROW_SCOPE(vm);
12244 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12245 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12246 if (!shouldAllowAccess)
12247 return false;
12248 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().webkitTransitionEndEvent, value);
12249 vm.heap.writeBarrier(&thisObject, value);
12250 ensureStillAliveHere(value);
12251
12252 return true;
12253}
12254
12255JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onwebkittransitionend, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
12256{
12257 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onwebkittransitionendSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
12258}
12259
12260static inline JSValue jsDOMWindow_onwheelGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
12261{
12262 auto& vm = JSC::getVM(&lexicalGlobalObject);
12263 auto throwScope = DECLARE_THROW_SCOPE(vm);
12264 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12265 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12266 if (!shouldAllowAccess)
12267 return jsUndefined();
12268 return eventHandlerAttribute(thisObject.wrapped(), eventNames().wheelEvent, worldForDOMObject(thisObject));
12269}
12270
12271JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onwheel, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
12272{
12273 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onwheelGetter>(*lexicalGlobalObject, thisValue, attributeName);
12274}
12275
12276static inline bool setJSDOMWindow_onwheelSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
12277{
12278 auto& vm = JSC::getVM(&lexicalGlobalObject);
12279 auto throwScope = DECLARE_THROW_SCOPE(vm);
12280 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12281 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12282 if (!shouldAllowAccess)
12283 return false;
12284 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().wheelEvent, value);
12285 vm.heap.writeBarrier(&thisObject, value);
12286 ensureStillAliveHere(value);
12287
12288 return true;
12289}
12290
12291JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onwheel, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
12292{
12293 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onwheelSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
12294}
12295
12296static inline JSValue jsDOMWindow_onmousewheelGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
12297{
12298 auto& vm = JSC::getVM(&lexicalGlobalObject);
12299 auto throwScope = DECLARE_THROW_SCOPE(vm);
12300 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12301 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12302 if (!shouldAllowAccess)
12303 return jsUndefined();
12304 return eventHandlerAttribute(thisObject.wrapped(), eventNames().mousewheelEvent, worldForDOMObject(thisObject));
12305}
12306
12307JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onmousewheel, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
12308{
12309 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onmousewheelGetter>(*lexicalGlobalObject, thisValue, attributeName);
12310}
12311
12312static inline bool setJSDOMWindow_onmousewheelSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
12313{
12314 auto& vm = JSC::getVM(&lexicalGlobalObject);
12315 auto throwScope = DECLARE_THROW_SCOPE(vm);
12316 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12317 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12318 if (!shouldAllowAccess)
12319 return false;
12320 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().mousewheelEvent, value);
12321 vm.heap.writeBarrier(&thisObject, value);
12322 ensureStillAliveHere(value);
12323
12324 return true;
12325}
12326
12327JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onmousewheel, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
12328{
12329 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onmousewheelSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
12330}
12331
12332static inline JSValue jsDOMWindow_onsearchGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
12333{
12334 auto& vm = JSC::getVM(&lexicalGlobalObject);
12335 auto throwScope = DECLARE_THROW_SCOPE(vm);
12336 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12337 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12338 if (!shouldAllowAccess)
12339 return jsUndefined();
12340 return eventHandlerAttribute(thisObject.wrapped(), eventNames().searchEvent, worldForDOMObject(thisObject));
12341}
12342
12343JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onsearch, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
12344{
12345 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onsearchGetter>(*lexicalGlobalObject, thisValue, attributeName);
12346}
12347
12348static inline bool setJSDOMWindow_onsearchSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
12349{
12350 auto& vm = JSC::getVM(&lexicalGlobalObject);
12351 auto throwScope = DECLARE_THROW_SCOPE(vm);
12352 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12353 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12354 if (!shouldAllowAccess)
12355 return false;
12356 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().searchEvent, value);
12357 vm.heap.writeBarrier(&thisObject, value);
12358 ensureStillAliveHere(value);
12359
12360 return true;
12361}
12362
12363JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onsearch, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
12364{
12365 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onsearchSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
12366}
12367
12368#if ENABLE(TOUCH_EVENTS)
12369static inline JSValue jsDOMWindow_ontouchcancelGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
12370{
12371 auto& vm = JSC::getVM(&lexicalGlobalObject);
12372 auto throwScope = DECLARE_THROW_SCOPE(vm);
12373 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12374 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12375 if (!shouldAllowAccess)
12376 return jsUndefined();
12377 return eventHandlerAttribute(thisObject.wrapped(), eventNames().touchcancelEvent, worldForDOMObject(thisObject));
12378}
12379
12380JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ontouchcancel, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
12381{
12382 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ontouchcancelGetter>(*lexicalGlobalObject, thisValue, attributeName);
12383}
12384
12385#endif
12386
12387#if ENABLE(TOUCH_EVENTS)
12388static inline bool setJSDOMWindow_ontouchcancelSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
12389{
12390 auto& vm = JSC::getVM(&lexicalGlobalObject);
12391 auto throwScope = DECLARE_THROW_SCOPE(vm);
12392 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12393 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12394 if (!shouldAllowAccess)
12395 return false;
12396 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().touchcancelEvent, value);
12397 vm.heap.writeBarrier(&thisObject, value);
12398 ensureStillAliveHere(value);
12399
12400 return true;
12401}
12402
12403JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_ontouchcancel, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
12404{
12405 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_ontouchcancelSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
12406}
12407
12408#endif
12409
12410#if ENABLE(TOUCH_EVENTS)
12411static inline JSValue jsDOMWindow_ontouchendGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
12412{
12413 auto& vm = JSC::getVM(&lexicalGlobalObject);
12414 auto throwScope = DECLARE_THROW_SCOPE(vm);
12415 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12416 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12417 if (!shouldAllowAccess)
12418 return jsUndefined();
12419 return eventHandlerAttribute(thisObject.wrapped(), eventNames().touchendEvent, worldForDOMObject(thisObject));
12420}
12421
12422JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ontouchend, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
12423{
12424 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ontouchendGetter>(*lexicalGlobalObject, thisValue, attributeName);
12425}
12426
12427#endif
12428
12429#if ENABLE(TOUCH_EVENTS)
12430static inline bool setJSDOMWindow_ontouchendSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
12431{
12432 auto& vm = JSC::getVM(&lexicalGlobalObject);
12433 auto throwScope = DECLARE_THROW_SCOPE(vm);
12434 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12435 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12436 if (!shouldAllowAccess)
12437 return false;
12438 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().touchendEvent, value);
12439 vm.heap.writeBarrier(&thisObject, value);
12440 ensureStillAliveHere(value);
12441
12442 return true;
12443}
12444
12445JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_ontouchend, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
12446{
12447 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_ontouchendSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
12448}
12449
12450#endif
12451
12452#if ENABLE(TOUCH_EVENTS)
12453static inline JSValue jsDOMWindow_ontouchmoveGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
12454{
12455 auto& vm = JSC::getVM(&lexicalGlobalObject);
12456 auto throwScope = DECLARE_THROW_SCOPE(vm);
12457 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12458 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12459 if (!shouldAllowAccess)
12460 return jsUndefined();
12461 return eventHandlerAttribute(thisObject.wrapped(), eventNames().touchmoveEvent, worldForDOMObject(thisObject));
12462}
12463
12464JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ontouchmove, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
12465{
12466 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ontouchmoveGetter>(*lexicalGlobalObject, thisValue, attributeName);
12467}
12468
12469#endif
12470
12471#if ENABLE(TOUCH_EVENTS)
12472static inline bool setJSDOMWindow_ontouchmoveSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
12473{
12474 auto& vm = JSC::getVM(&lexicalGlobalObject);
12475 auto throwScope = DECLARE_THROW_SCOPE(vm);
12476 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12477 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12478 if (!shouldAllowAccess)
12479 return false;
12480 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().touchmoveEvent, value);
12481 vm.heap.writeBarrier(&thisObject, value);
12482 ensureStillAliveHere(value);
12483
12484 return true;
12485}
12486
12487JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_ontouchmove, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
12488{
12489 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_ontouchmoveSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
12490}
12491
12492#endif
12493
12494#if ENABLE(TOUCH_EVENTS)
12495static inline JSValue jsDOMWindow_ontouchstartGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
12496{
12497 auto& vm = JSC::getVM(&lexicalGlobalObject);
12498 auto throwScope = DECLARE_THROW_SCOPE(vm);
12499 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12500 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12501 if (!shouldAllowAccess)
12502 return jsUndefined();
12503 return eventHandlerAttribute(thisObject.wrapped(), eventNames().touchstartEvent, worldForDOMObject(thisObject));
12504}
12505
12506JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ontouchstart, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
12507{
12508 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ontouchstartGetter>(*lexicalGlobalObject, thisValue, attributeName);
12509}
12510
12511#endif
12512
12513#if ENABLE(TOUCH_EVENTS)
12514static inline bool setJSDOMWindow_ontouchstartSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
12515{
12516 auto& vm = JSC::getVM(&lexicalGlobalObject);
12517 auto throwScope = DECLARE_THROW_SCOPE(vm);
12518 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12519 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12520 if (!shouldAllowAccess)
12521 return false;
12522 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().touchstartEvent, value);
12523 vm.heap.writeBarrier(&thisObject, value);
12524 ensureStillAliveHere(value);
12525
12526 return true;
12527}
12528
12529JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_ontouchstart, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
12530{
12531 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_ontouchstartSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
12532}
12533
12534#endif
12535
12536#if ENABLE(TOUCH_EVENTS)
12537static inline JSValue jsDOMWindow_ontouchforcechangeGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
12538{
12539 auto& vm = JSC::getVM(&lexicalGlobalObject);
12540 auto throwScope = DECLARE_THROW_SCOPE(vm);
12541 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12542 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12543 if (!shouldAllowAccess)
12544 return jsUndefined();
12545 return eventHandlerAttribute(thisObject.wrapped(), eventNames().touchforcechangeEvent, worldForDOMObject(thisObject));
12546}
12547
12548JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ontouchforcechange, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
12549{
12550 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ontouchforcechangeGetter>(*lexicalGlobalObject, thisValue, attributeName);
12551}
12552
12553#endif
12554
12555#if ENABLE(TOUCH_EVENTS)
12556static inline bool setJSDOMWindow_ontouchforcechangeSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
12557{
12558 auto& vm = JSC::getVM(&lexicalGlobalObject);
12559 auto throwScope = DECLARE_THROW_SCOPE(vm);
12560 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12561 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12562 if (!shouldAllowAccess)
12563 return false;
12564 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().touchforcechangeEvent, value);
12565 vm.heap.writeBarrier(&thisObject, value);
12566 ensureStillAliveHere(value);
12567
12568 return true;
12569}
12570
12571JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_ontouchforcechange, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
12572{
12573 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_ontouchforcechangeSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
12574}
12575
12576#endif
12577
12578#if ENABLE(MOUSE_FORCE_EVENTS)
12579static inline JSValue jsDOMWindow_onwebkitmouseforcechangedGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
12580{
12581 auto& vm = JSC::getVM(&lexicalGlobalObject);
12582 auto throwScope = DECLARE_THROW_SCOPE(vm);
12583 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12584 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12585 if (!shouldAllowAccess)
12586 return jsUndefined();
12587 return eventHandlerAttribute(thisObject.wrapped(), eventNames().webkitmouseforcechangedEvent, worldForDOMObject(thisObject));
12588}
12589
12590JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onwebkitmouseforcechanged, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
12591{
12592 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onwebkitmouseforcechangedGetter>(*lexicalGlobalObject, thisValue, attributeName);
12593}
12594
12595#endif
12596
12597#if ENABLE(MOUSE_FORCE_EVENTS)
12598static inline bool setJSDOMWindow_onwebkitmouseforcechangedSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
12599{
12600 auto& vm = JSC::getVM(&lexicalGlobalObject);
12601 auto throwScope = DECLARE_THROW_SCOPE(vm);
12602 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12603 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12604 if (!shouldAllowAccess)
12605 return false;
12606 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().webkitmouseforcechangedEvent, value);
12607 vm.heap.writeBarrier(&thisObject, value);
12608 ensureStillAliveHere(value);
12609
12610 return true;
12611}
12612
12613JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onwebkitmouseforcechanged, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
12614{
12615 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onwebkitmouseforcechangedSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
12616}
12617
12618#endif
12619
12620#if ENABLE(MOUSE_FORCE_EVENTS)
12621static inline JSValue jsDOMWindow_onwebkitmouseforcedownGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
12622{
12623 auto& vm = JSC::getVM(&lexicalGlobalObject);
12624 auto throwScope = DECLARE_THROW_SCOPE(vm);
12625 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12626 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12627 if (!shouldAllowAccess)
12628 return jsUndefined();
12629 return eventHandlerAttribute(thisObject.wrapped(), eventNames().webkitmouseforcedownEvent, worldForDOMObject(thisObject));
12630}
12631
12632JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onwebkitmouseforcedown, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
12633{
12634 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onwebkitmouseforcedownGetter>(*lexicalGlobalObject, thisValue, attributeName);
12635}
12636
12637#endif
12638
12639#if ENABLE(MOUSE_FORCE_EVENTS)
12640static inline bool setJSDOMWindow_onwebkitmouseforcedownSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
12641{
12642 auto& vm = JSC::getVM(&lexicalGlobalObject);
12643 auto throwScope = DECLARE_THROW_SCOPE(vm);
12644 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12645 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12646 if (!shouldAllowAccess)
12647 return false;
12648 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().webkitmouseforcedownEvent, value);
12649 vm.heap.writeBarrier(&thisObject, value);
12650 ensureStillAliveHere(value);
12651
12652 return true;
12653}
12654
12655JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onwebkitmouseforcedown, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
12656{
12657 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onwebkitmouseforcedownSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
12658}
12659
12660#endif
12661
12662#if ENABLE(MOUSE_FORCE_EVENTS)
12663static inline JSValue jsDOMWindow_onwebkitmouseforcewillbeginGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
12664{
12665 auto& vm = JSC::getVM(&lexicalGlobalObject);
12666 auto throwScope = DECLARE_THROW_SCOPE(vm);
12667 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12668 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12669 if (!shouldAllowAccess)
12670 return jsUndefined();
12671 return eventHandlerAttribute(thisObject.wrapped(), eventNames().webkitmouseforcewillbeginEvent, worldForDOMObject(thisObject));
12672}
12673
12674JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onwebkitmouseforcewillbegin, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
12675{
12676 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onwebkitmouseforcewillbeginGetter>(*lexicalGlobalObject, thisValue, attributeName);
12677}
12678
12679#endif
12680
12681#if ENABLE(MOUSE_FORCE_EVENTS)
12682static inline bool setJSDOMWindow_onwebkitmouseforcewillbeginSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
12683{
12684 auto& vm = JSC::getVM(&lexicalGlobalObject);
12685 auto throwScope = DECLARE_THROW_SCOPE(vm);
12686 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12687 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12688 if (!shouldAllowAccess)
12689 return false;
12690 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().webkitmouseforcewillbeginEvent, value);
12691 vm.heap.writeBarrier(&thisObject, value);
12692 ensureStillAliveHere(value);
12693
12694 return true;
12695}
12696
12697JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onwebkitmouseforcewillbegin, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
12698{
12699 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onwebkitmouseforcewillbeginSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
12700}
12701
12702#endif
12703
12704#if ENABLE(MOUSE_FORCE_EVENTS)
12705static inline JSValue jsDOMWindow_onwebkitmouseforceupGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
12706{
12707 auto& vm = JSC::getVM(&lexicalGlobalObject);
12708 auto throwScope = DECLARE_THROW_SCOPE(vm);
12709 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12710 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12711 if (!shouldAllowAccess)
12712 return jsUndefined();
12713 return eventHandlerAttribute(thisObject.wrapped(), eventNames().webkitmouseforceupEvent, worldForDOMObject(thisObject));
12714}
12715
12716JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onwebkitmouseforceup, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
12717{
12718 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onwebkitmouseforceupGetter>(*lexicalGlobalObject, thisValue, attributeName);
12719}
12720
12721#endif
12722
12723#if ENABLE(MOUSE_FORCE_EVENTS)
12724static inline bool setJSDOMWindow_onwebkitmouseforceupSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
12725{
12726 auto& vm = JSC::getVM(&lexicalGlobalObject);
12727 auto throwScope = DECLARE_THROW_SCOPE(vm);
12728 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12729 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12730 if (!shouldAllowAccess)
12731 return false;
12732 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().webkitmouseforceupEvent, value);
12733 vm.heap.writeBarrier(&thisObject, value);
12734 ensureStillAliveHere(value);
12735
12736 return true;
12737}
12738
12739JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onwebkitmouseforceup, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
12740{
12741 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onwebkitmouseforceupSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
12742}
12743
12744#endif
12745
12746static inline JSValue jsDOMWindow_onanimationstartGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
12747{
12748 auto& vm = JSC::getVM(&lexicalGlobalObject);
12749 auto throwScope = DECLARE_THROW_SCOPE(vm);
12750 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12751 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12752 if (!shouldAllowAccess)
12753 return jsUndefined();
12754 return eventHandlerAttribute(thisObject.wrapped(), eventNames().animationstartEvent, worldForDOMObject(thisObject));
12755}
12756
12757JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onanimationstart, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
12758{
12759 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onanimationstartGetter>(*lexicalGlobalObject, thisValue, attributeName);
12760}
12761
12762static inline bool setJSDOMWindow_onanimationstartSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
12763{
12764 auto& vm = JSC::getVM(&lexicalGlobalObject);
12765 auto throwScope = DECLARE_THROW_SCOPE(vm);
12766 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12767 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12768 if (!shouldAllowAccess)
12769 return false;
12770 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().animationstartEvent, value);
12771 vm.heap.writeBarrier(&thisObject, value);
12772 ensureStillAliveHere(value);
12773
12774 return true;
12775}
12776
12777JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onanimationstart, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
12778{
12779 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onanimationstartSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
12780}
12781
12782static inline JSValue jsDOMWindow_onanimationiterationGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
12783{
12784 auto& vm = JSC::getVM(&lexicalGlobalObject);
12785 auto throwScope = DECLARE_THROW_SCOPE(vm);
12786 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12787 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12788 if (!shouldAllowAccess)
12789 return jsUndefined();
12790 return eventHandlerAttribute(thisObject.wrapped(), eventNames().animationiterationEvent, worldForDOMObject(thisObject));
12791}
12792
12793JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onanimationiteration, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
12794{
12795 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onanimationiterationGetter>(*lexicalGlobalObject, thisValue, attributeName);
12796}
12797
12798static inline bool setJSDOMWindow_onanimationiterationSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
12799{
12800 auto& vm = JSC::getVM(&lexicalGlobalObject);
12801 auto throwScope = DECLARE_THROW_SCOPE(vm);
12802 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12803 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12804 if (!shouldAllowAccess)
12805 return false;
12806 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().animationiterationEvent, value);
12807 vm.heap.writeBarrier(&thisObject, value);
12808 ensureStillAliveHere(value);
12809
12810 return true;
12811}
12812
12813JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onanimationiteration, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
12814{
12815 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onanimationiterationSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
12816}
12817
12818static inline JSValue jsDOMWindow_onanimationendGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
12819{
12820 auto& vm = JSC::getVM(&lexicalGlobalObject);
12821 auto throwScope = DECLARE_THROW_SCOPE(vm);
12822 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12823 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12824 if (!shouldAllowAccess)
12825 return jsUndefined();
12826 return eventHandlerAttribute(thisObject.wrapped(), eventNames().animationendEvent, worldForDOMObject(thisObject));
12827}
12828
12829JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onanimationend, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
12830{
12831 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onanimationendGetter>(*lexicalGlobalObject, thisValue, attributeName);
12832}
12833
12834static inline bool setJSDOMWindow_onanimationendSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
12835{
12836 auto& vm = JSC::getVM(&lexicalGlobalObject);
12837 auto throwScope = DECLARE_THROW_SCOPE(vm);
12838 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12839 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12840 if (!shouldAllowAccess)
12841 return false;
12842 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().animationendEvent, value);
12843 vm.heap.writeBarrier(&thisObject, value);
12844 ensureStillAliveHere(value);
12845
12846 return true;
12847}
12848
12849JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onanimationend, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
12850{
12851 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onanimationendSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
12852}
12853
12854static inline JSValue jsDOMWindow_onanimationcancelGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
12855{
12856 auto& vm = JSC::getVM(&lexicalGlobalObject);
12857 auto throwScope = DECLARE_THROW_SCOPE(vm);
12858 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12859 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12860 if (!shouldAllowAccess)
12861 return jsUndefined();
12862 return eventHandlerAttribute(thisObject.wrapped(), eventNames().animationcancelEvent, worldForDOMObject(thisObject));
12863}
12864
12865JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onanimationcancel, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
12866{
12867 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onanimationcancelGetter>(*lexicalGlobalObject, thisValue, attributeName);
12868}
12869
12870static inline bool setJSDOMWindow_onanimationcancelSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
12871{
12872 auto& vm = JSC::getVM(&lexicalGlobalObject);
12873 auto throwScope = DECLARE_THROW_SCOPE(vm);
12874 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12875 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12876 if (!shouldAllowAccess)
12877 return false;
12878 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().animationcancelEvent, value);
12879 vm.heap.writeBarrier(&thisObject, value);
12880 ensureStillAliveHere(value);
12881
12882 return true;
12883}
12884
12885JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onanimationcancel, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
12886{
12887 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onanimationcancelSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
12888}
12889
12890static inline JSValue jsDOMWindow_ontransitionrunGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
12891{
12892 auto& vm = JSC::getVM(&lexicalGlobalObject);
12893 auto throwScope = DECLARE_THROW_SCOPE(vm);
12894 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12895 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12896 if (!shouldAllowAccess)
12897 return jsUndefined();
12898 return eventHandlerAttribute(thisObject.wrapped(), eventNames().transitionrunEvent, worldForDOMObject(thisObject));
12899}
12900
12901JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ontransitionrun, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
12902{
12903 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ontransitionrunGetter>(*lexicalGlobalObject, thisValue, attributeName);
12904}
12905
12906static inline bool setJSDOMWindow_ontransitionrunSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
12907{
12908 auto& vm = JSC::getVM(&lexicalGlobalObject);
12909 auto throwScope = DECLARE_THROW_SCOPE(vm);
12910 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12911 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12912 if (!shouldAllowAccess)
12913 return false;
12914 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().transitionrunEvent, value);
12915 vm.heap.writeBarrier(&thisObject, value);
12916 ensureStillAliveHere(value);
12917
12918 return true;
12919}
12920
12921JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_ontransitionrun, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
12922{
12923 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_ontransitionrunSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
12924}
12925
12926static inline JSValue jsDOMWindow_ontransitionstartGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
12927{
12928 auto& vm = JSC::getVM(&lexicalGlobalObject);
12929 auto throwScope = DECLARE_THROW_SCOPE(vm);
12930 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12931 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12932 if (!shouldAllowAccess)
12933 return jsUndefined();
12934 return eventHandlerAttribute(thisObject.wrapped(), eventNames().transitionstartEvent, worldForDOMObject(thisObject));
12935}
12936
12937JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ontransitionstart, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
12938{
12939 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ontransitionstartGetter>(*lexicalGlobalObject, thisValue, attributeName);
12940}
12941
12942static inline bool setJSDOMWindow_ontransitionstartSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
12943{
12944 auto& vm = JSC::getVM(&lexicalGlobalObject);
12945 auto throwScope = DECLARE_THROW_SCOPE(vm);
12946 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12947 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12948 if (!shouldAllowAccess)
12949 return false;
12950 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().transitionstartEvent, value);
12951 vm.heap.writeBarrier(&thisObject, value);
12952 ensureStillAliveHere(value);
12953
12954 return true;
12955}
12956
12957JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_ontransitionstart, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
12958{
12959 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_ontransitionstartSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
12960}
12961
12962static inline JSValue jsDOMWindow_ontransitionendGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
12963{
12964 auto& vm = JSC::getVM(&lexicalGlobalObject);
12965 auto throwScope = DECLARE_THROW_SCOPE(vm);
12966 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12967 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12968 if (!shouldAllowAccess)
12969 return jsUndefined();
12970 return eventHandlerAttribute(thisObject.wrapped(), eventNames().transitionendEvent, worldForDOMObject(thisObject));
12971}
12972
12973JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ontransitionend, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
12974{
12975 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ontransitionendGetter>(*lexicalGlobalObject, thisValue, attributeName);
12976}
12977
12978static inline bool setJSDOMWindow_ontransitionendSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
12979{
12980 auto& vm = JSC::getVM(&lexicalGlobalObject);
12981 auto throwScope = DECLARE_THROW_SCOPE(vm);
12982 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
12983 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
12984 if (!shouldAllowAccess)
12985 return false;
12986 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().transitionendEvent, value);
12987 vm.heap.writeBarrier(&thisObject, value);
12988 ensureStillAliveHere(value);
12989
12990 return true;
12991}
12992
12993JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_ontransitionend, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
12994{
12995 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_ontransitionendSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
12996}
12997
12998static inline JSValue jsDOMWindow_ontransitioncancelGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
12999{
13000 auto& vm = JSC::getVM(&lexicalGlobalObject);
13001 auto throwScope = DECLARE_THROW_SCOPE(vm);
13002 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13003 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13004 if (!shouldAllowAccess)
13005 return jsUndefined();
13006 return eventHandlerAttribute(thisObject.wrapped(), eventNames().transitioncancelEvent, worldForDOMObject(thisObject));
13007}
13008
13009JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ontransitioncancel, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
13010{
13011 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ontransitioncancelGetter>(*lexicalGlobalObject, thisValue, attributeName);
13012}
13013
13014static inline bool setJSDOMWindow_ontransitioncancelSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
13015{
13016 auto& vm = JSC::getVM(&lexicalGlobalObject);
13017 auto throwScope = DECLARE_THROW_SCOPE(vm);
13018 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13019 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13020 if (!shouldAllowAccess)
13021 return false;
13022 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().transitioncancelEvent, value);
13023 vm.heap.writeBarrier(&thisObject, value);
13024 ensureStillAliveHere(value);
13025
13026 return true;
13027}
13028
13029JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_ontransitioncancel, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
13030{
13031 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_ontransitioncancelSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
13032}
13033
13034static inline JSValue jsDOMWindow_ongotpointercaptureGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
13035{
13036 auto& vm = JSC::getVM(&lexicalGlobalObject);
13037 auto throwScope = DECLARE_THROW_SCOPE(vm);
13038 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13039 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13040 if (!shouldAllowAccess)
13041 return jsUndefined();
13042 return eventHandlerAttribute(thisObject.wrapped(), eventNames().gotpointercaptureEvent, worldForDOMObject(thisObject));
13043}
13044
13045JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ongotpointercapture, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
13046{
13047 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ongotpointercaptureGetter>(*lexicalGlobalObject, thisValue, attributeName);
13048}
13049
13050static inline bool setJSDOMWindow_ongotpointercaptureSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
13051{
13052 auto& vm = JSC::getVM(&lexicalGlobalObject);
13053 auto throwScope = DECLARE_THROW_SCOPE(vm);
13054 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13055 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13056 if (!shouldAllowAccess)
13057 return false;
13058 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().gotpointercaptureEvent, value);
13059 vm.heap.writeBarrier(&thisObject, value);
13060 ensureStillAliveHere(value);
13061
13062 return true;
13063}
13064
13065JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_ongotpointercapture, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
13066{
13067 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_ongotpointercaptureSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
13068}
13069
13070static inline JSValue jsDOMWindow_onlostpointercaptureGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
13071{
13072 auto& vm = JSC::getVM(&lexicalGlobalObject);
13073 auto throwScope = DECLARE_THROW_SCOPE(vm);
13074 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13075 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13076 if (!shouldAllowAccess)
13077 return jsUndefined();
13078 return eventHandlerAttribute(thisObject.wrapped(), eventNames().lostpointercaptureEvent, worldForDOMObject(thisObject));
13079}
13080
13081JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onlostpointercapture, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
13082{
13083 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onlostpointercaptureGetter>(*lexicalGlobalObject, thisValue, attributeName);
13084}
13085
13086static inline bool setJSDOMWindow_onlostpointercaptureSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
13087{
13088 auto& vm = JSC::getVM(&lexicalGlobalObject);
13089 auto throwScope = DECLARE_THROW_SCOPE(vm);
13090 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13091 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13092 if (!shouldAllowAccess)
13093 return false;
13094 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().lostpointercaptureEvent, value);
13095 vm.heap.writeBarrier(&thisObject, value);
13096 ensureStillAliveHere(value);
13097
13098 return true;
13099}
13100
13101JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onlostpointercapture, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
13102{
13103 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onlostpointercaptureSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
13104}
13105
13106static inline JSValue jsDOMWindow_onpointerdownGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
13107{
13108 auto& vm = JSC::getVM(&lexicalGlobalObject);
13109 auto throwScope = DECLARE_THROW_SCOPE(vm);
13110 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13111 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13112 if (!shouldAllowAccess)
13113 return jsUndefined();
13114 return eventHandlerAttribute(thisObject.wrapped(), eventNames().pointerdownEvent, worldForDOMObject(thisObject));
13115}
13116
13117JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onpointerdown, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
13118{
13119 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onpointerdownGetter>(*lexicalGlobalObject, thisValue, attributeName);
13120}
13121
13122static inline bool setJSDOMWindow_onpointerdownSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
13123{
13124 auto& vm = JSC::getVM(&lexicalGlobalObject);
13125 auto throwScope = DECLARE_THROW_SCOPE(vm);
13126 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13127 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13128 if (!shouldAllowAccess)
13129 return false;
13130 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().pointerdownEvent, value);
13131 vm.heap.writeBarrier(&thisObject, value);
13132 ensureStillAliveHere(value);
13133
13134 return true;
13135}
13136
13137JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onpointerdown, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
13138{
13139 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onpointerdownSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
13140}
13141
13142static inline JSValue jsDOMWindow_onpointermoveGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
13143{
13144 auto& vm = JSC::getVM(&lexicalGlobalObject);
13145 auto throwScope = DECLARE_THROW_SCOPE(vm);
13146 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13147 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13148 if (!shouldAllowAccess)
13149 return jsUndefined();
13150 return eventHandlerAttribute(thisObject.wrapped(), eventNames().pointermoveEvent, worldForDOMObject(thisObject));
13151}
13152
13153JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onpointermove, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
13154{
13155 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onpointermoveGetter>(*lexicalGlobalObject, thisValue, attributeName);
13156}
13157
13158static inline bool setJSDOMWindow_onpointermoveSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
13159{
13160 auto& vm = JSC::getVM(&lexicalGlobalObject);
13161 auto throwScope = DECLARE_THROW_SCOPE(vm);
13162 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13163 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13164 if (!shouldAllowAccess)
13165 return false;
13166 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().pointermoveEvent, value);
13167 vm.heap.writeBarrier(&thisObject, value);
13168 ensureStillAliveHere(value);
13169
13170 return true;
13171}
13172
13173JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onpointermove, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
13174{
13175 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onpointermoveSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
13176}
13177
13178static inline JSValue jsDOMWindow_onpointerupGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
13179{
13180 auto& vm = JSC::getVM(&lexicalGlobalObject);
13181 auto throwScope = DECLARE_THROW_SCOPE(vm);
13182 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13183 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13184 if (!shouldAllowAccess)
13185 return jsUndefined();
13186 return eventHandlerAttribute(thisObject.wrapped(), eventNames().pointerupEvent, worldForDOMObject(thisObject));
13187}
13188
13189JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onpointerup, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
13190{
13191 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onpointerupGetter>(*lexicalGlobalObject, thisValue, attributeName);
13192}
13193
13194static inline bool setJSDOMWindow_onpointerupSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
13195{
13196 auto& vm = JSC::getVM(&lexicalGlobalObject);
13197 auto throwScope = DECLARE_THROW_SCOPE(vm);
13198 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13199 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13200 if (!shouldAllowAccess)
13201 return false;
13202 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().pointerupEvent, value);
13203 vm.heap.writeBarrier(&thisObject, value);
13204 ensureStillAliveHere(value);
13205
13206 return true;
13207}
13208
13209JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onpointerup, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
13210{
13211 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onpointerupSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
13212}
13213
13214static inline JSValue jsDOMWindow_onpointercancelGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
13215{
13216 auto& vm = JSC::getVM(&lexicalGlobalObject);
13217 auto throwScope = DECLARE_THROW_SCOPE(vm);
13218 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13219 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13220 if (!shouldAllowAccess)
13221 return jsUndefined();
13222 return eventHandlerAttribute(thisObject.wrapped(), eventNames().pointercancelEvent, worldForDOMObject(thisObject));
13223}
13224
13225JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onpointercancel, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
13226{
13227 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onpointercancelGetter>(*lexicalGlobalObject, thisValue, attributeName);
13228}
13229
13230static inline bool setJSDOMWindow_onpointercancelSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
13231{
13232 auto& vm = JSC::getVM(&lexicalGlobalObject);
13233 auto throwScope = DECLARE_THROW_SCOPE(vm);
13234 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13235 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13236 if (!shouldAllowAccess)
13237 return false;
13238 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().pointercancelEvent, value);
13239 vm.heap.writeBarrier(&thisObject, value);
13240 ensureStillAliveHere(value);
13241
13242 return true;
13243}
13244
13245JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onpointercancel, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
13246{
13247 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onpointercancelSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
13248}
13249
13250static inline JSValue jsDOMWindow_onpointeroverGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
13251{
13252 auto& vm = JSC::getVM(&lexicalGlobalObject);
13253 auto throwScope = DECLARE_THROW_SCOPE(vm);
13254 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13255 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13256 if (!shouldAllowAccess)
13257 return jsUndefined();
13258 return eventHandlerAttribute(thisObject.wrapped(), eventNames().pointeroverEvent, worldForDOMObject(thisObject));
13259}
13260
13261JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onpointerover, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
13262{
13263 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onpointeroverGetter>(*lexicalGlobalObject, thisValue, attributeName);
13264}
13265
13266static inline bool setJSDOMWindow_onpointeroverSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
13267{
13268 auto& vm = JSC::getVM(&lexicalGlobalObject);
13269 auto throwScope = DECLARE_THROW_SCOPE(vm);
13270 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13271 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13272 if (!shouldAllowAccess)
13273 return false;
13274 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().pointeroverEvent, value);
13275 vm.heap.writeBarrier(&thisObject, value);
13276 ensureStillAliveHere(value);
13277
13278 return true;
13279}
13280
13281JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onpointerover, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
13282{
13283 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onpointeroverSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
13284}
13285
13286static inline JSValue jsDOMWindow_onpointeroutGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
13287{
13288 auto& vm = JSC::getVM(&lexicalGlobalObject);
13289 auto throwScope = DECLARE_THROW_SCOPE(vm);
13290 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13291 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13292 if (!shouldAllowAccess)
13293 return jsUndefined();
13294 return eventHandlerAttribute(thisObject.wrapped(), eventNames().pointeroutEvent, worldForDOMObject(thisObject));
13295}
13296
13297JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onpointerout, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
13298{
13299 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onpointeroutGetter>(*lexicalGlobalObject, thisValue, attributeName);
13300}
13301
13302static inline bool setJSDOMWindow_onpointeroutSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
13303{
13304 auto& vm = JSC::getVM(&lexicalGlobalObject);
13305 auto throwScope = DECLARE_THROW_SCOPE(vm);
13306 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13307 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13308 if (!shouldAllowAccess)
13309 return false;
13310 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().pointeroutEvent, value);
13311 vm.heap.writeBarrier(&thisObject, value);
13312 ensureStillAliveHere(value);
13313
13314 return true;
13315}
13316
13317JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onpointerout, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
13318{
13319 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onpointeroutSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
13320}
13321
13322static inline JSValue jsDOMWindow_onpointerenterGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
13323{
13324 auto& vm = JSC::getVM(&lexicalGlobalObject);
13325 auto throwScope = DECLARE_THROW_SCOPE(vm);
13326 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13327 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13328 if (!shouldAllowAccess)
13329 return jsUndefined();
13330 return eventHandlerAttribute(thisObject.wrapped(), eventNames().pointerenterEvent, worldForDOMObject(thisObject));
13331}
13332
13333JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onpointerenter, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
13334{
13335 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onpointerenterGetter>(*lexicalGlobalObject, thisValue, attributeName);
13336}
13337
13338static inline bool setJSDOMWindow_onpointerenterSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
13339{
13340 auto& vm = JSC::getVM(&lexicalGlobalObject);
13341 auto throwScope = DECLARE_THROW_SCOPE(vm);
13342 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13343 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13344 if (!shouldAllowAccess)
13345 return false;
13346 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().pointerenterEvent, value);
13347 vm.heap.writeBarrier(&thisObject, value);
13348 ensureStillAliveHere(value);
13349
13350 return true;
13351}
13352
13353JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onpointerenter, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
13354{
13355 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onpointerenterSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
13356}
13357
13358static inline JSValue jsDOMWindow_onpointerleaveGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
13359{
13360 auto& vm = JSC::getVM(&lexicalGlobalObject);
13361 auto throwScope = DECLARE_THROW_SCOPE(vm);
13362 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13363 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13364 if (!shouldAllowAccess)
13365 return jsUndefined();
13366 return eventHandlerAttribute(thisObject.wrapped(), eventNames().pointerleaveEvent, worldForDOMObject(thisObject));
13367}
13368
13369JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onpointerleave, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
13370{
13371 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onpointerleaveGetter>(*lexicalGlobalObject, thisValue, attributeName);
13372}
13373
13374static inline bool setJSDOMWindow_onpointerleaveSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
13375{
13376 auto& vm = JSC::getVM(&lexicalGlobalObject);
13377 auto throwScope = DECLARE_THROW_SCOPE(vm);
13378 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13379 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13380 if (!shouldAllowAccess)
13381 return false;
13382 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().pointerleaveEvent, value);
13383 vm.heap.writeBarrier(&thisObject, value);
13384 ensureStillAliveHere(value);
13385
13386 return true;
13387}
13388
13389JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onpointerleave, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
13390{
13391 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onpointerleaveSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
13392}
13393
13394static inline JSValue jsDOMWindow_onselectstartGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
13395{
13396 auto& vm = JSC::getVM(&lexicalGlobalObject);
13397 auto throwScope = DECLARE_THROW_SCOPE(vm);
13398 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13399 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13400 if (!shouldAllowAccess)
13401 return jsUndefined();
13402 return eventHandlerAttribute(thisObject.wrapped(), eventNames().selectstartEvent, worldForDOMObject(thisObject));
13403}
13404
13405JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onselectstart, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
13406{
13407 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onselectstartGetter>(*lexicalGlobalObject, thisValue, attributeName);
13408}
13409
13410static inline bool setJSDOMWindow_onselectstartSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
13411{
13412 auto& vm = JSC::getVM(&lexicalGlobalObject);
13413 auto throwScope = DECLARE_THROW_SCOPE(vm);
13414 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13415 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13416 if (!shouldAllowAccess)
13417 return false;
13418 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().selectstartEvent, value);
13419 vm.heap.writeBarrier(&thisObject, value);
13420 ensureStillAliveHere(value);
13421
13422 return true;
13423}
13424
13425JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onselectstart, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
13426{
13427 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onselectstartSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
13428}
13429
13430static inline JSValue jsDOMWindow_onselectionchangeGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
13431{
13432 auto& vm = JSC::getVM(&lexicalGlobalObject);
13433 auto throwScope = DECLARE_THROW_SCOPE(vm);
13434 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13435 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13436 if (!shouldAllowAccess)
13437 return jsUndefined();
13438 return eventHandlerAttribute(thisObject.wrapped(), eventNames().selectionchangeEvent, worldForDOMObject(thisObject));
13439}
13440
13441JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onselectionchange, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
13442{
13443 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onselectionchangeGetter>(*lexicalGlobalObject, thisValue, attributeName);
13444}
13445
13446static inline bool setJSDOMWindow_onselectionchangeSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
13447{
13448 auto& vm = JSC::getVM(&lexicalGlobalObject);
13449 auto throwScope = DECLARE_THROW_SCOPE(vm);
13450 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13451 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13452 if (!shouldAllowAccess)
13453 return false;
13454 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().selectionchangeEvent, value);
13455 vm.heap.writeBarrier(&thisObject, value);
13456 ensureStillAliveHere(value);
13457
13458 return true;
13459}
13460
13461JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onselectionchange, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
13462{
13463 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onselectionchangeSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
13464}
13465
13466static inline JSValue jsDOMWindow_screenGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
13467{
13468 auto& vm = JSC::getVM(&lexicalGlobalObject);
13469 auto throwScope = DECLARE_THROW_SCOPE(vm);
13470 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13471 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13472 if (!shouldAllowAccess)
13473 return jsUndefined();
13474 auto& impl = thisObject.wrapped();
13475 RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<Screen>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.screen())));
13476}
13477
13478JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_screen, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
13479{
13480 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_screenGetter>(*lexicalGlobalObject, thisValue, attributeName);
13481}
13482
13483static inline bool setJSDOMWindow_screenSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
13484{
13485 auto& vm = JSC::getVM(&lexicalGlobalObject);
13486 auto throwScope = DECLARE_THROW_SCOPE(vm);
13487 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13488 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13489 if (!shouldAllowAccess)
13490 return false;
13491 // Shadowing a built-in property.
13492 return replaceStaticPropertySlot(vm, &thisObject, Identifier::fromString(vm, reinterpret_cast<const LChar*>("screen"), strlen("screen")), value);
13493}
13494
13495JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_screen, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
13496{
13497 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_screenSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
13498}
13499
13500static inline JSValue jsDOMWindow_innerWidthGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
13501{
13502 auto& vm = JSC::getVM(&lexicalGlobalObject);
13503 auto throwScope = DECLARE_THROW_SCOPE(vm);
13504 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13505 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13506 if (!shouldAllowAccess)
13507 return jsUndefined();
13508 auto& impl = thisObject.wrapped();
13509 RELEASE_AND_RETURN(throwScope, (toJS<IDLLong>(lexicalGlobalObject, throwScope, impl.innerWidth())));
13510}
13511
13512JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_innerWidth, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
13513{
13514 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_innerWidthGetter>(*lexicalGlobalObject, thisValue, attributeName);
13515}
13516
13517static inline bool setJSDOMWindow_innerWidthSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
13518{
13519 auto& vm = JSC::getVM(&lexicalGlobalObject);
13520 auto throwScope = DECLARE_THROW_SCOPE(vm);
13521 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13522 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13523 if (!shouldAllowAccess)
13524 return false;
13525 // Shadowing a built-in property.
13526 return replaceStaticPropertySlot(vm, &thisObject, Identifier::fromString(vm, reinterpret_cast<const LChar*>("innerWidth"), strlen("innerWidth")), value);
13527}
13528
13529JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_innerWidth, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
13530{
13531 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_innerWidthSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
13532}
13533
13534static inline JSValue jsDOMWindow_innerHeightGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
13535{
13536 auto& vm = JSC::getVM(&lexicalGlobalObject);
13537 auto throwScope = DECLARE_THROW_SCOPE(vm);
13538 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13539 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13540 if (!shouldAllowAccess)
13541 return jsUndefined();
13542 auto& impl = thisObject.wrapped();
13543 RELEASE_AND_RETURN(throwScope, (toJS<IDLLong>(lexicalGlobalObject, throwScope, impl.innerHeight())));
13544}
13545
13546JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_innerHeight, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
13547{
13548 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_innerHeightGetter>(*lexicalGlobalObject, thisValue, attributeName);
13549}
13550
13551static inline bool setJSDOMWindow_innerHeightSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
13552{
13553 auto& vm = JSC::getVM(&lexicalGlobalObject);
13554 auto throwScope = DECLARE_THROW_SCOPE(vm);
13555 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13556 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13557 if (!shouldAllowAccess)
13558 return false;
13559 // Shadowing a built-in property.
13560 return replaceStaticPropertySlot(vm, &thisObject, Identifier::fromString(vm, reinterpret_cast<const LChar*>("innerHeight"), strlen("innerHeight")), value);
13561}
13562
13563JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_innerHeight, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
13564{
13565 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_innerHeightSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
13566}
13567
13568static inline JSValue jsDOMWindow_scrollXGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
13569{
13570 auto& vm = JSC::getVM(&lexicalGlobalObject);
13571 auto throwScope = DECLARE_THROW_SCOPE(vm);
13572 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13573 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13574 if (!shouldAllowAccess)
13575 return jsUndefined();
13576 auto& impl = thisObject.wrapped();
13577 RELEASE_AND_RETURN(throwScope, (toJS<IDLDouble>(lexicalGlobalObject, throwScope, impl.scrollX())));
13578}
13579
13580JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_scrollX, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
13581{
13582 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_scrollXGetter>(*lexicalGlobalObject, thisValue, attributeName);
13583}
13584
13585static inline bool setJSDOMWindow_scrollXSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
13586{
13587 auto& vm = JSC::getVM(&lexicalGlobalObject);
13588 auto throwScope = DECLARE_THROW_SCOPE(vm);
13589 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13590 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13591 if (!shouldAllowAccess)
13592 return false;
13593 // Shadowing a built-in property.
13594 return replaceStaticPropertySlot(vm, &thisObject, Identifier::fromString(vm, reinterpret_cast<const LChar*>("scrollX"), strlen("scrollX")), value);
13595}
13596
13597JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_scrollX, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
13598{
13599 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_scrollXSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
13600}
13601
13602static inline JSValue jsDOMWindow_pageXOffsetGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
13603{
13604 auto& vm = JSC::getVM(&lexicalGlobalObject);
13605 auto throwScope = DECLARE_THROW_SCOPE(vm);
13606 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13607 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13608 if (!shouldAllowAccess)
13609 return jsUndefined();
13610 auto& impl = thisObject.wrapped();
13611 RELEASE_AND_RETURN(throwScope, (toJS<IDLDouble>(lexicalGlobalObject, throwScope, impl.scrollX())));
13612}
13613
13614JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_pageXOffset, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
13615{
13616 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_pageXOffsetGetter>(*lexicalGlobalObject, thisValue, attributeName);
13617}
13618
13619static inline bool setJSDOMWindow_pageXOffsetSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
13620{
13621 auto& vm = JSC::getVM(&lexicalGlobalObject);
13622 auto throwScope = DECLARE_THROW_SCOPE(vm);
13623 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13624 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13625 if (!shouldAllowAccess)
13626 return false;
13627 // Shadowing a built-in property.
13628 return replaceStaticPropertySlot(vm, &thisObject, Identifier::fromString(vm, reinterpret_cast<const LChar*>("pageXOffset"), strlen("pageXOffset")), value);
13629}
13630
13631JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_pageXOffset, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
13632{
13633 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_pageXOffsetSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
13634}
13635
13636static inline JSValue jsDOMWindow_scrollYGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
13637{
13638 auto& vm = JSC::getVM(&lexicalGlobalObject);
13639 auto throwScope = DECLARE_THROW_SCOPE(vm);
13640 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13641 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13642 if (!shouldAllowAccess)
13643 return jsUndefined();
13644 auto& impl = thisObject.wrapped();
13645 RELEASE_AND_RETURN(throwScope, (toJS<IDLDouble>(lexicalGlobalObject, throwScope, impl.scrollY())));
13646}
13647
13648JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_scrollY, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
13649{
13650 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_scrollYGetter>(*lexicalGlobalObject, thisValue, attributeName);
13651}
13652
13653static inline bool setJSDOMWindow_scrollYSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
13654{
13655 auto& vm = JSC::getVM(&lexicalGlobalObject);
13656 auto throwScope = DECLARE_THROW_SCOPE(vm);
13657 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13658 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13659 if (!shouldAllowAccess)
13660 return false;
13661 // Shadowing a built-in property.
13662 return replaceStaticPropertySlot(vm, &thisObject, Identifier::fromString(vm, reinterpret_cast<const LChar*>("scrollY"), strlen("scrollY")), value);
13663}
13664
13665JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_scrollY, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
13666{
13667 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_scrollYSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
13668}
13669
13670static inline JSValue jsDOMWindow_pageYOffsetGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
13671{
13672 auto& vm = JSC::getVM(&lexicalGlobalObject);
13673 auto throwScope = DECLARE_THROW_SCOPE(vm);
13674 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13675 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13676 if (!shouldAllowAccess)
13677 return jsUndefined();
13678 auto& impl = thisObject.wrapped();
13679 RELEASE_AND_RETURN(throwScope, (toJS<IDLDouble>(lexicalGlobalObject, throwScope, impl.scrollY())));
13680}
13681
13682JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_pageYOffset, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
13683{
13684 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_pageYOffsetGetter>(*lexicalGlobalObject, thisValue, attributeName);
13685}
13686
13687static inline bool setJSDOMWindow_pageYOffsetSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
13688{
13689 auto& vm = JSC::getVM(&lexicalGlobalObject);
13690 auto throwScope = DECLARE_THROW_SCOPE(vm);
13691 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13692 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13693 if (!shouldAllowAccess)
13694 return false;
13695 // Shadowing a built-in property.
13696 return replaceStaticPropertySlot(vm, &thisObject, Identifier::fromString(vm, reinterpret_cast<const LChar*>("pageYOffset"), strlen("pageYOffset")), value);
13697}
13698
13699JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_pageYOffset, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
13700{
13701 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_pageYOffsetSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
13702}
13703
13704static inline JSValue jsDOMWindow_screenXGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
13705{
13706 auto& vm = JSC::getVM(&lexicalGlobalObject);
13707 auto throwScope = DECLARE_THROW_SCOPE(vm);
13708 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13709 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13710 if (!shouldAllowAccess)
13711 return jsUndefined();
13712 auto& impl = thisObject.wrapped();
13713 RELEASE_AND_RETURN(throwScope, (toJS<IDLLong>(lexicalGlobalObject, throwScope, impl.screenX())));
13714}
13715
13716JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_screenX, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
13717{
13718 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_screenXGetter>(*lexicalGlobalObject, thisValue, attributeName);
13719}
13720
13721static inline bool setJSDOMWindow_screenXSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
13722{
13723 auto& vm = JSC::getVM(&lexicalGlobalObject);
13724 auto throwScope = DECLARE_THROW_SCOPE(vm);
13725 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13726 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13727 if (!shouldAllowAccess)
13728 return false;
13729 // Shadowing a built-in property.
13730 return replaceStaticPropertySlot(vm, &thisObject, Identifier::fromString(vm, reinterpret_cast<const LChar*>("screenX"), strlen("screenX")), value);
13731}
13732
13733JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_screenX, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
13734{
13735 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_screenXSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
13736}
13737
13738static inline JSValue jsDOMWindow_screenLeftGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
13739{
13740 auto& vm = JSC::getVM(&lexicalGlobalObject);
13741 auto throwScope = DECLARE_THROW_SCOPE(vm);
13742 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13743 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13744 if (!shouldAllowAccess)
13745 return jsUndefined();
13746 auto& impl = thisObject.wrapped();
13747 RELEASE_AND_RETURN(throwScope, (toJS<IDLLong>(lexicalGlobalObject, throwScope, impl.screenLeft())));
13748}
13749
13750JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_screenLeft, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
13751{
13752 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_screenLeftGetter>(*lexicalGlobalObject, thisValue, attributeName);
13753}
13754
13755static inline bool setJSDOMWindow_screenLeftSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
13756{
13757 auto& vm = JSC::getVM(&lexicalGlobalObject);
13758 auto throwScope = DECLARE_THROW_SCOPE(vm);
13759 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13760 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13761 if (!shouldAllowAccess)
13762 return false;
13763 // Shadowing a built-in property.
13764 return replaceStaticPropertySlot(vm, &thisObject, Identifier::fromString(vm, reinterpret_cast<const LChar*>("screenLeft"), strlen("screenLeft")), value);
13765}
13766
13767JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_screenLeft, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
13768{
13769 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_screenLeftSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
13770}
13771
13772static inline JSValue jsDOMWindow_screenYGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
13773{
13774 auto& vm = JSC::getVM(&lexicalGlobalObject);
13775 auto throwScope = DECLARE_THROW_SCOPE(vm);
13776 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13777 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13778 if (!shouldAllowAccess)
13779 return jsUndefined();
13780 auto& impl = thisObject.wrapped();
13781 RELEASE_AND_RETURN(throwScope, (toJS<IDLLong>(lexicalGlobalObject, throwScope, impl.screenY())));
13782}
13783
13784JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_screenY, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
13785{
13786 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_screenYGetter>(*lexicalGlobalObject, thisValue, attributeName);
13787}
13788
13789static inline bool setJSDOMWindow_screenYSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
13790{
13791 auto& vm = JSC::getVM(&lexicalGlobalObject);
13792 auto throwScope = DECLARE_THROW_SCOPE(vm);
13793 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13794 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13795 if (!shouldAllowAccess)
13796 return false;
13797 // Shadowing a built-in property.
13798 return replaceStaticPropertySlot(vm, &thisObject, Identifier::fromString(vm, reinterpret_cast<const LChar*>("screenY"), strlen("screenY")), value);
13799}
13800
13801JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_screenY, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
13802{
13803 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_screenYSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
13804}
13805
13806static inline JSValue jsDOMWindow_screenTopGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
13807{
13808 auto& vm = JSC::getVM(&lexicalGlobalObject);
13809 auto throwScope = DECLARE_THROW_SCOPE(vm);
13810 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13811 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13812 if (!shouldAllowAccess)
13813 return jsUndefined();
13814 auto& impl = thisObject.wrapped();
13815 RELEASE_AND_RETURN(throwScope, (toJS<IDLLong>(lexicalGlobalObject, throwScope, impl.screenTop())));
13816}
13817
13818JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_screenTop, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
13819{
13820 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_screenTopGetter>(*lexicalGlobalObject, thisValue, attributeName);
13821}
13822
13823static inline bool setJSDOMWindow_screenTopSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
13824{
13825 auto& vm = JSC::getVM(&lexicalGlobalObject);
13826 auto throwScope = DECLARE_THROW_SCOPE(vm);
13827 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13828 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13829 if (!shouldAllowAccess)
13830 return false;
13831 // Shadowing a built-in property.
13832 return replaceStaticPropertySlot(vm, &thisObject, Identifier::fromString(vm, reinterpret_cast<const LChar*>("screenTop"), strlen("screenTop")), value);
13833}
13834
13835JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_screenTop, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
13836{
13837 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_screenTopSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
13838}
13839
13840static inline JSValue jsDOMWindow_outerWidthGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
13841{
13842 auto& vm = JSC::getVM(&lexicalGlobalObject);
13843 auto throwScope = DECLARE_THROW_SCOPE(vm);
13844 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13845 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13846 if (!shouldAllowAccess)
13847 return jsUndefined();
13848 auto& impl = thisObject.wrapped();
13849 RELEASE_AND_RETURN(throwScope, (toJS<IDLLong>(lexicalGlobalObject, throwScope, impl.outerWidth())));
13850}
13851
13852JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_outerWidth, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
13853{
13854 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_outerWidthGetter>(*lexicalGlobalObject, thisValue, attributeName);
13855}
13856
13857static inline bool setJSDOMWindow_outerWidthSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
13858{
13859 auto& vm = JSC::getVM(&lexicalGlobalObject);
13860 auto throwScope = DECLARE_THROW_SCOPE(vm);
13861 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13862 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13863 if (!shouldAllowAccess)
13864 return false;
13865 // Shadowing a built-in property.
13866 return replaceStaticPropertySlot(vm, &thisObject, Identifier::fromString(vm, reinterpret_cast<const LChar*>("outerWidth"), strlen("outerWidth")), value);
13867}
13868
13869JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_outerWidth, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
13870{
13871 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_outerWidthSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
13872}
13873
13874static inline JSValue jsDOMWindow_outerHeightGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
13875{
13876 auto& vm = JSC::getVM(&lexicalGlobalObject);
13877 auto throwScope = DECLARE_THROW_SCOPE(vm);
13878 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13879 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13880 if (!shouldAllowAccess)
13881 return jsUndefined();
13882 auto& impl = thisObject.wrapped();
13883 RELEASE_AND_RETURN(throwScope, (toJS<IDLLong>(lexicalGlobalObject, throwScope, impl.outerHeight())));
13884}
13885
13886JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_outerHeight, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
13887{
13888 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_outerHeightGetter>(*lexicalGlobalObject, thisValue, attributeName);
13889}
13890
13891static inline bool setJSDOMWindow_outerHeightSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
13892{
13893 auto& vm = JSC::getVM(&lexicalGlobalObject);
13894 auto throwScope = DECLARE_THROW_SCOPE(vm);
13895 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13896 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13897 if (!shouldAllowAccess)
13898 return false;
13899 // Shadowing a built-in property.
13900 return replaceStaticPropertySlot(vm, &thisObject, Identifier::fromString(vm, reinterpret_cast<const LChar*>("outerHeight"), strlen("outerHeight")), value);
13901}
13902
13903JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_outerHeight, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
13904{
13905 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_outerHeightSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
13906}
13907
13908static inline JSValue jsDOMWindow_devicePixelRatioGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
13909{
13910 auto& vm = JSC::getVM(&lexicalGlobalObject);
13911 auto throwScope = DECLARE_THROW_SCOPE(vm);
13912 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13913 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13914 if (!shouldAllowAccess)
13915 return jsUndefined();
13916 auto& impl = thisObject.wrapped();
13917 RELEASE_AND_RETURN(throwScope, (toJS<IDLDouble>(lexicalGlobalObject, throwScope, impl.devicePixelRatio())));
13918}
13919
13920JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_devicePixelRatio, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
13921{
13922 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_devicePixelRatioGetter>(*lexicalGlobalObject, thisValue, attributeName);
13923}
13924
13925static inline bool setJSDOMWindow_devicePixelRatioSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
13926{
13927 auto& vm = JSC::getVM(&lexicalGlobalObject);
13928 auto throwScope = DECLARE_THROW_SCOPE(vm);
13929 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13930 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13931 if (!shouldAllowAccess)
13932 return false;
13933 // Shadowing a built-in property.
13934 return replaceStaticPropertySlot(vm, &thisObject, Identifier::fromString(vm, reinterpret_cast<const LChar*>("devicePixelRatio"), strlen("devicePixelRatio")), value);
13935}
13936
13937JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_devicePixelRatio, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
13938{
13939 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_devicePixelRatioSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
13940}
13941
13942static inline JSValue jsDOMWindow_styleMediaGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
13943{
13944 auto& vm = JSC::getVM(&lexicalGlobalObject);
13945 auto throwScope = DECLARE_THROW_SCOPE(vm);
13946 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13947 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13948 if (!shouldAllowAccess)
13949 return jsUndefined();
13950 auto& impl = thisObject.wrapped();
13951 RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<StyleMedia>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.styleMedia())));
13952}
13953
13954JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_styleMedia, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
13955{
13956 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_styleMediaGetter>(*lexicalGlobalObject, thisValue, attributeName);
13957}
13958
13959#if ENABLE(ORIENTATION_EVENTS)
13960static inline JSValue jsDOMWindow_orientationGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
13961{
13962 auto& vm = JSC::getVM(&lexicalGlobalObject);
13963 auto throwScope = DECLARE_THROW_SCOPE(vm);
13964 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13965 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13966 if (!shouldAllowAccess)
13967 return jsUndefined();
13968 auto& impl = thisObject.wrapped();
13969 RELEASE_AND_RETURN(throwScope, (toJS<IDLShort>(lexicalGlobalObject, throwScope, impl.orientation())));
13970}
13971
13972JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_orientation, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
13973{
13974 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_orientationGetter>(*lexicalGlobalObject, thisValue, attributeName);
13975}
13976
13977#endif
13978
13979#if ENABLE(ORIENTATION_EVENTS)
13980static inline JSValue jsDOMWindow_onorientationchangeGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
13981{
13982 auto& vm = JSC::getVM(&lexicalGlobalObject);
13983 auto throwScope = DECLARE_THROW_SCOPE(vm);
13984 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
13985 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
13986 if (!shouldAllowAccess)
13987 return jsUndefined();
13988 return windowEventHandlerAttribute(thisObject.wrapped(), eventNames().orientationchangeEvent, worldForDOMObject(thisObject));
13989}
13990
13991JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onorientationchange, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
13992{
13993 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onorientationchangeGetter>(*lexicalGlobalObject, thisValue, attributeName);
13994}
13995
13996#endif
13997
13998#if ENABLE(ORIENTATION_EVENTS)
13999static inline bool setJSDOMWindow_onorientationchangeSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
14000{
14001 auto& vm = JSC::getVM(&lexicalGlobalObject);
14002 auto throwScope = DECLARE_THROW_SCOPE(vm);
14003 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14004 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14005 if (!shouldAllowAccess)
14006 return false;
14007 setWindowEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().orientationchangeEvent, value);
14008 vm.heap.writeBarrier(&thisObject, value);
14009 ensureStillAliveHere(value);
14010
14011 return true;
14012}
14013
14014JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onorientationchange, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
14015{
14016 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onorientationchangeSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
14017}
14018
14019#endif
14020
14021#if ENABLE(DEVICE_ORIENTATION)
14022static inline JSValue jsDOMWindow_ondevicemotionGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
14023{
14024 auto& vm = JSC::getVM(&lexicalGlobalObject);
14025 auto throwScope = DECLARE_THROW_SCOPE(vm);
14026 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14027 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14028 if (!shouldAllowAccess)
14029 return jsUndefined();
14030 return eventHandlerAttribute(thisObject.wrapped(), eventNames().devicemotionEvent, worldForDOMObject(thisObject));
14031}
14032
14033JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ondevicemotion, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
14034{
14035 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ondevicemotionGetter>(*lexicalGlobalObject, thisValue, attributeName);
14036}
14037
14038#endif
14039
14040#if ENABLE(DEVICE_ORIENTATION)
14041static inline bool setJSDOMWindow_ondevicemotionSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
14042{
14043 auto& vm = JSC::getVM(&lexicalGlobalObject);
14044 auto throwScope = DECLARE_THROW_SCOPE(vm);
14045 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14046 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14047 if (!shouldAllowAccess)
14048 return false;
14049 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().devicemotionEvent, value);
14050 vm.heap.writeBarrier(&thisObject, value);
14051 ensureStillAliveHere(value);
14052
14053 return true;
14054}
14055
14056JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_ondevicemotion, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
14057{
14058 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_ondevicemotionSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
14059}
14060
14061#endif
14062
14063#if ENABLE(DEVICE_ORIENTATION)
14064static inline JSValue jsDOMWindow_ondeviceorientationGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
14065{
14066 auto& vm = JSC::getVM(&lexicalGlobalObject);
14067 auto throwScope = DECLARE_THROW_SCOPE(vm);
14068 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14069 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14070 if (!shouldAllowAccess)
14071 return jsUndefined();
14072 return eventHandlerAttribute(thisObject.wrapped(), eventNames().deviceorientationEvent, worldForDOMObject(thisObject));
14073}
14074
14075JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ondeviceorientation, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
14076{
14077 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ondeviceorientationGetter>(*lexicalGlobalObject, thisValue, attributeName);
14078}
14079
14080#endif
14081
14082#if ENABLE(DEVICE_ORIENTATION)
14083static inline bool setJSDOMWindow_ondeviceorientationSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
14084{
14085 auto& vm = JSC::getVM(&lexicalGlobalObject);
14086 auto throwScope = DECLARE_THROW_SCOPE(vm);
14087 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14088 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14089 if (!shouldAllowAccess)
14090 return false;
14091 setEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().deviceorientationEvent, value);
14092 vm.heap.writeBarrier(&thisObject, value);
14093 ensureStillAliveHere(value);
14094
14095 return true;
14096}
14097
14098JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_ondeviceorientation, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
14099{
14100 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_ondeviceorientationSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
14101}
14102
14103#endif
14104
14105static inline JSValue jsDOMWindow_visualViewportGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
14106{
14107 auto& vm = JSC::getVM(&lexicalGlobalObject);
14108 auto throwScope = DECLARE_THROW_SCOPE(vm);
14109 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14110 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14111 if (!shouldAllowAccess)
14112 return jsUndefined();
14113 auto& impl = thisObject.wrapped();
14114 RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<VisualViewport>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.visualViewport())));
14115}
14116
14117JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_visualViewport, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
14118{
14119 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_visualViewportGetter>(*lexicalGlobalObject, thisValue, attributeName);
14120}
14121
14122static inline bool setJSDOMWindow_visualViewportSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
14123{
14124 auto& vm = JSC::getVM(&lexicalGlobalObject);
14125 auto throwScope = DECLARE_THROW_SCOPE(vm);
14126 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14127 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14128 if (!shouldAllowAccess)
14129 return false;
14130 // Shadowing a built-in property.
14131 return replaceStaticPropertySlot(vm, &thisObject, Identifier::fromString(vm, reinterpret_cast<const LChar*>("visualViewport"), strlen("visualViewport")), value);
14132}
14133
14134JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_visualViewport, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
14135{
14136 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_visualViewportSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
14137}
14138
14139static inline JSValue jsDOMWindow_onafterprintGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
14140{
14141 auto& vm = JSC::getVM(&lexicalGlobalObject);
14142 auto throwScope = DECLARE_THROW_SCOPE(vm);
14143 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14144 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14145 if (!shouldAllowAccess)
14146 return jsUndefined();
14147 return windowEventHandlerAttribute(thisObject.wrapped(), eventNames().afterprintEvent, worldForDOMObject(thisObject));
14148}
14149
14150JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onafterprint, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
14151{
14152 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onafterprintGetter>(*lexicalGlobalObject, thisValue, attributeName);
14153}
14154
14155static inline bool setJSDOMWindow_onafterprintSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
14156{
14157 auto& vm = JSC::getVM(&lexicalGlobalObject);
14158 auto throwScope = DECLARE_THROW_SCOPE(vm);
14159 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14160 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14161 if (!shouldAllowAccess)
14162 return false;
14163 setWindowEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().afterprintEvent, value);
14164 vm.heap.writeBarrier(&thisObject, value);
14165 ensureStillAliveHere(value);
14166
14167 return true;
14168}
14169
14170JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onafterprint, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
14171{
14172 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onafterprintSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
14173}
14174
14175static inline JSValue jsDOMWindow_onbeforeprintGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
14176{
14177 auto& vm = JSC::getVM(&lexicalGlobalObject);
14178 auto throwScope = DECLARE_THROW_SCOPE(vm);
14179 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14180 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14181 if (!shouldAllowAccess)
14182 return jsUndefined();
14183 return windowEventHandlerAttribute(thisObject.wrapped(), eventNames().beforeprintEvent, worldForDOMObject(thisObject));
14184}
14185
14186JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onbeforeprint, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
14187{
14188 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onbeforeprintGetter>(*lexicalGlobalObject, thisValue, attributeName);
14189}
14190
14191static inline bool setJSDOMWindow_onbeforeprintSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
14192{
14193 auto& vm = JSC::getVM(&lexicalGlobalObject);
14194 auto throwScope = DECLARE_THROW_SCOPE(vm);
14195 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14196 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14197 if (!shouldAllowAccess)
14198 return false;
14199 setWindowEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().beforeprintEvent, value);
14200 vm.heap.writeBarrier(&thisObject, value);
14201 ensureStillAliveHere(value);
14202
14203 return true;
14204}
14205
14206JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onbeforeprint, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
14207{
14208 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onbeforeprintSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
14209}
14210
14211static inline JSValue jsDOMWindow_onbeforeunloadGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
14212{
14213 auto& vm = JSC::getVM(&lexicalGlobalObject);
14214 auto throwScope = DECLARE_THROW_SCOPE(vm);
14215 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14216 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14217 if (!shouldAllowAccess)
14218 return jsUndefined();
14219 return windowEventHandlerAttribute(thisObject.wrapped(), eventNames().beforeunloadEvent, worldForDOMObject(thisObject));
14220}
14221
14222JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onbeforeunload, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
14223{
14224 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onbeforeunloadGetter>(*lexicalGlobalObject, thisValue, attributeName);
14225}
14226
14227static inline bool setJSDOMWindow_onbeforeunloadSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
14228{
14229 auto& vm = JSC::getVM(&lexicalGlobalObject);
14230 auto throwScope = DECLARE_THROW_SCOPE(vm);
14231 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14232 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14233 if (!shouldAllowAccess)
14234 return false;
14235 setWindowEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().beforeunloadEvent, value);
14236 vm.heap.writeBarrier(&thisObject, value);
14237 ensureStillAliveHere(value);
14238
14239 return true;
14240}
14241
14242JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onbeforeunload, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
14243{
14244 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onbeforeunloadSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
14245}
14246
14247static inline JSValue jsDOMWindow_onhashchangeGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
14248{
14249 auto& vm = JSC::getVM(&lexicalGlobalObject);
14250 auto throwScope = DECLARE_THROW_SCOPE(vm);
14251 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14252 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14253 if (!shouldAllowAccess)
14254 return jsUndefined();
14255 return windowEventHandlerAttribute(thisObject.wrapped(), eventNames().hashchangeEvent, worldForDOMObject(thisObject));
14256}
14257
14258JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onhashchange, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
14259{
14260 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onhashchangeGetter>(*lexicalGlobalObject, thisValue, attributeName);
14261}
14262
14263static inline bool setJSDOMWindow_onhashchangeSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
14264{
14265 auto& vm = JSC::getVM(&lexicalGlobalObject);
14266 auto throwScope = DECLARE_THROW_SCOPE(vm);
14267 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14268 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14269 if (!shouldAllowAccess)
14270 return false;
14271 setWindowEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().hashchangeEvent, value);
14272 vm.heap.writeBarrier(&thisObject, value);
14273 ensureStillAliveHere(value);
14274
14275 return true;
14276}
14277
14278JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onhashchange, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
14279{
14280 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onhashchangeSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
14281}
14282
14283static inline JSValue jsDOMWindow_onlanguagechangeGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
14284{
14285 auto& vm = JSC::getVM(&lexicalGlobalObject);
14286 auto throwScope = DECLARE_THROW_SCOPE(vm);
14287 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14288 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14289 if (!shouldAllowAccess)
14290 return jsUndefined();
14291 return windowEventHandlerAttribute(thisObject.wrapped(), eventNames().languagechangeEvent, worldForDOMObject(thisObject));
14292}
14293
14294JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onlanguagechange, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
14295{
14296 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onlanguagechangeGetter>(*lexicalGlobalObject, thisValue, attributeName);
14297}
14298
14299static inline bool setJSDOMWindow_onlanguagechangeSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
14300{
14301 auto& vm = JSC::getVM(&lexicalGlobalObject);
14302 auto throwScope = DECLARE_THROW_SCOPE(vm);
14303 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14304 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14305 if (!shouldAllowAccess)
14306 return false;
14307 setWindowEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().languagechangeEvent, value);
14308 vm.heap.writeBarrier(&thisObject, value);
14309 ensureStillAliveHere(value);
14310
14311 return true;
14312}
14313
14314JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onlanguagechange, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
14315{
14316 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onlanguagechangeSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
14317}
14318
14319static inline JSValue jsDOMWindow_onmessageGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
14320{
14321 auto& vm = JSC::getVM(&lexicalGlobalObject);
14322 auto throwScope = DECLARE_THROW_SCOPE(vm);
14323 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14324 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14325 if (!shouldAllowAccess)
14326 return jsUndefined();
14327 return windowEventHandlerAttribute(thisObject.wrapped(), eventNames().messageEvent, worldForDOMObject(thisObject));
14328}
14329
14330JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onmessage, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
14331{
14332 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onmessageGetter>(*lexicalGlobalObject, thisValue, attributeName);
14333}
14334
14335static inline bool setJSDOMWindow_onmessageSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
14336{
14337 auto& vm = JSC::getVM(&lexicalGlobalObject);
14338 auto throwScope = DECLARE_THROW_SCOPE(vm);
14339 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14340 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14341 if (!shouldAllowAccess)
14342 return false;
14343 setWindowEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().messageEvent, value);
14344 vm.heap.writeBarrier(&thisObject, value);
14345 ensureStillAliveHere(value);
14346
14347 return true;
14348}
14349
14350JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onmessage, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
14351{
14352 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onmessageSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
14353}
14354
14355static inline JSValue jsDOMWindow_onofflineGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
14356{
14357 auto& vm = JSC::getVM(&lexicalGlobalObject);
14358 auto throwScope = DECLARE_THROW_SCOPE(vm);
14359 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14360 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14361 if (!shouldAllowAccess)
14362 return jsUndefined();
14363 return windowEventHandlerAttribute(thisObject.wrapped(), eventNames().offlineEvent, worldForDOMObject(thisObject));
14364}
14365
14366JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onoffline, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
14367{
14368 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onofflineGetter>(*lexicalGlobalObject, thisValue, attributeName);
14369}
14370
14371static inline bool setJSDOMWindow_onofflineSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
14372{
14373 auto& vm = JSC::getVM(&lexicalGlobalObject);
14374 auto throwScope = DECLARE_THROW_SCOPE(vm);
14375 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14376 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14377 if (!shouldAllowAccess)
14378 return false;
14379 setWindowEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().offlineEvent, value);
14380 vm.heap.writeBarrier(&thisObject, value);
14381 ensureStillAliveHere(value);
14382
14383 return true;
14384}
14385
14386JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onoffline, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
14387{
14388 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onofflineSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
14389}
14390
14391static inline JSValue jsDOMWindow_ononlineGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
14392{
14393 auto& vm = JSC::getVM(&lexicalGlobalObject);
14394 auto throwScope = DECLARE_THROW_SCOPE(vm);
14395 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14396 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14397 if (!shouldAllowAccess)
14398 return jsUndefined();
14399 return windowEventHandlerAttribute(thisObject.wrapped(), eventNames().onlineEvent, worldForDOMObject(thisObject));
14400}
14401
14402JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ononline, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
14403{
14404 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ononlineGetter>(*lexicalGlobalObject, thisValue, attributeName);
14405}
14406
14407static inline bool setJSDOMWindow_ononlineSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
14408{
14409 auto& vm = JSC::getVM(&lexicalGlobalObject);
14410 auto throwScope = DECLARE_THROW_SCOPE(vm);
14411 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14412 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14413 if (!shouldAllowAccess)
14414 return false;
14415 setWindowEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().onlineEvent, value);
14416 vm.heap.writeBarrier(&thisObject, value);
14417 ensureStillAliveHere(value);
14418
14419 return true;
14420}
14421
14422JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_ononline, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
14423{
14424 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_ononlineSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
14425}
14426
14427static inline JSValue jsDOMWindow_onpagehideGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
14428{
14429 auto& vm = JSC::getVM(&lexicalGlobalObject);
14430 auto throwScope = DECLARE_THROW_SCOPE(vm);
14431 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14432 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14433 if (!shouldAllowAccess)
14434 return jsUndefined();
14435 return windowEventHandlerAttribute(thisObject.wrapped(), eventNames().pagehideEvent, worldForDOMObject(thisObject));
14436}
14437
14438JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onpagehide, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
14439{
14440 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onpagehideGetter>(*lexicalGlobalObject, thisValue, attributeName);
14441}
14442
14443static inline bool setJSDOMWindow_onpagehideSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
14444{
14445 auto& vm = JSC::getVM(&lexicalGlobalObject);
14446 auto throwScope = DECLARE_THROW_SCOPE(vm);
14447 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14448 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14449 if (!shouldAllowAccess)
14450 return false;
14451 setWindowEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().pagehideEvent, value);
14452 vm.heap.writeBarrier(&thisObject, value);
14453 ensureStillAliveHere(value);
14454
14455 return true;
14456}
14457
14458JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onpagehide, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
14459{
14460 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onpagehideSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
14461}
14462
14463static inline JSValue jsDOMWindow_onpageshowGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
14464{
14465 auto& vm = JSC::getVM(&lexicalGlobalObject);
14466 auto throwScope = DECLARE_THROW_SCOPE(vm);
14467 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14468 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14469 if (!shouldAllowAccess)
14470 return jsUndefined();
14471 return windowEventHandlerAttribute(thisObject.wrapped(), eventNames().pageshowEvent, worldForDOMObject(thisObject));
14472}
14473
14474JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onpageshow, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
14475{
14476 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onpageshowGetter>(*lexicalGlobalObject, thisValue, attributeName);
14477}
14478
14479static inline bool setJSDOMWindow_onpageshowSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
14480{
14481 auto& vm = JSC::getVM(&lexicalGlobalObject);
14482 auto throwScope = DECLARE_THROW_SCOPE(vm);
14483 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14484 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14485 if (!shouldAllowAccess)
14486 return false;
14487 setWindowEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().pageshowEvent, value);
14488 vm.heap.writeBarrier(&thisObject, value);
14489 ensureStillAliveHere(value);
14490
14491 return true;
14492}
14493
14494JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onpageshow, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
14495{
14496 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onpageshowSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
14497}
14498
14499static inline JSValue jsDOMWindow_onpopstateGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
14500{
14501 auto& vm = JSC::getVM(&lexicalGlobalObject);
14502 auto throwScope = DECLARE_THROW_SCOPE(vm);
14503 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14504 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14505 if (!shouldAllowAccess)
14506 return jsUndefined();
14507 return windowEventHandlerAttribute(thisObject.wrapped(), eventNames().popstateEvent, worldForDOMObject(thisObject));
14508}
14509
14510JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onpopstate, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
14511{
14512 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onpopstateGetter>(*lexicalGlobalObject, thisValue, attributeName);
14513}
14514
14515static inline bool setJSDOMWindow_onpopstateSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
14516{
14517 auto& vm = JSC::getVM(&lexicalGlobalObject);
14518 auto throwScope = DECLARE_THROW_SCOPE(vm);
14519 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14520 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14521 if (!shouldAllowAccess)
14522 return false;
14523 setWindowEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().popstateEvent, value);
14524 vm.heap.writeBarrier(&thisObject, value);
14525 ensureStillAliveHere(value);
14526
14527 return true;
14528}
14529
14530JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onpopstate, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
14531{
14532 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onpopstateSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
14533}
14534
14535static inline JSValue jsDOMWindow_onrejectionhandledGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
14536{
14537 auto& vm = JSC::getVM(&lexicalGlobalObject);
14538 auto throwScope = DECLARE_THROW_SCOPE(vm);
14539 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14540 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14541 if (!shouldAllowAccess)
14542 return jsUndefined();
14543 return windowEventHandlerAttribute(thisObject.wrapped(), eventNames().rejectionhandledEvent, worldForDOMObject(thisObject));
14544}
14545
14546JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onrejectionhandled, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
14547{
14548 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onrejectionhandledGetter>(*lexicalGlobalObject, thisValue, attributeName);
14549}
14550
14551static inline bool setJSDOMWindow_onrejectionhandledSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
14552{
14553 auto& vm = JSC::getVM(&lexicalGlobalObject);
14554 auto throwScope = DECLARE_THROW_SCOPE(vm);
14555 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14556 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14557 if (!shouldAllowAccess)
14558 return false;
14559 setWindowEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().rejectionhandledEvent, value);
14560 vm.heap.writeBarrier(&thisObject, value);
14561 ensureStillAliveHere(value);
14562
14563 return true;
14564}
14565
14566JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onrejectionhandled, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
14567{
14568 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onrejectionhandledSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
14569}
14570
14571static inline JSValue jsDOMWindow_onstorageGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
14572{
14573 auto& vm = JSC::getVM(&lexicalGlobalObject);
14574 auto throwScope = DECLARE_THROW_SCOPE(vm);
14575 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14576 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14577 if (!shouldAllowAccess)
14578 return jsUndefined();
14579 return windowEventHandlerAttribute(thisObject.wrapped(), eventNames().storageEvent, worldForDOMObject(thisObject));
14580}
14581
14582JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onstorage, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
14583{
14584 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onstorageGetter>(*lexicalGlobalObject, thisValue, attributeName);
14585}
14586
14587static inline bool setJSDOMWindow_onstorageSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
14588{
14589 auto& vm = JSC::getVM(&lexicalGlobalObject);
14590 auto throwScope = DECLARE_THROW_SCOPE(vm);
14591 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14592 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14593 if (!shouldAllowAccess)
14594 return false;
14595 setWindowEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().storageEvent, value);
14596 vm.heap.writeBarrier(&thisObject, value);
14597 ensureStillAliveHere(value);
14598
14599 return true;
14600}
14601
14602JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onstorage, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
14603{
14604 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onstorageSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
14605}
14606
14607static inline JSValue jsDOMWindow_onunhandledrejectionGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
14608{
14609 auto& vm = JSC::getVM(&lexicalGlobalObject);
14610 auto throwScope = DECLARE_THROW_SCOPE(vm);
14611 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14612 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14613 if (!shouldAllowAccess)
14614 return jsUndefined();
14615 return windowEventHandlerAttribute(thisObject.wrapped(), eventNames().unhandledrejectionEvent, worldForDOMObject(thisObject));
14616}
14617
14618JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onunhandledrejection, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
14619{
14620 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onunhandledrejectionGetter>(*lexicalGlobalObject, thisValue, attributeName);
14621}
14622
14623static inline bool setJSDOMWindow_onunhandledrejectionSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
14624{
14625 auto& vm = JSC::getVM(&lexicalGlobalObject);
14626 auto throwScope = DECLARE_THROW_SCOPE(vm);
14627 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14628 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14629 if (!shouldAllowAccess)
14630 return false;
14631 setWindowEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().unhandledrejectionEvent, value);
14632 vm.heap.writeBarrier(&thisObject, value);
14633 ensureStillAliveHere(value);
14634
14635 return true;
14636}
14637
14638JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onunhandledrejection, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
14639{
14640 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onunhandledrejectionSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
14641}
14642
14643static inline JSValue jsDOMWindow_onunloadGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
14644{
14645 auto& vm = JSC::getVM(&lexicalGlobalObject);
14646 auto throwScope = DECLARE_THROW_SCOPE(vm);
14647 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14648 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14649 if (!shouldAllowAccess)
14650 return jsUndefined();
14651 return windowEventHandlerAttribute(thisObject.wrapped(), eventNames().unloadEvent, worldForDOMObject(thisObject));
14652}
14653
14654JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_onunload, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
14655{
14656 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_onunloadGetter>(*lexicalGlobalObject, thisValue, attributeName);
14657}
14658
14659static inline bool setJSDOMWindow_onunloadSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
14660{
14661 auto& vm = JSC::getVM(&lexicalGlobalObject);
14662 auto throwScope = DECLARE_THROW_SCOPE(vm);
14663 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14664 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14665 if (!shouldAllowAccess)
14666 return false;
14667 setWindowEventHandlerAttribute(lexicalGlobalObject, thisObject, thisObject.wrapped(), eventNames().unloadEvent, value);
14668 vm.heap.writeBarrier(&thisObject, value);
14669 ensureStillAliveHere(value);
14670
14671 return true;
14672}
14673
14674JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_onunload, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
14675{
14676 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_onunloadSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
14677}
14678
14679static inline JSValue jsDOMWindow_localStorageGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
14680{
14681 auto& vm = JSC::getVM(&lexicalGlobalObject);
14682 auto throwScope = DECLARE_THROW_SCOPE(vm);
14683 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14684 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14685 if (!shouldAllowAccess)
14686 return jsUndefined();
14687 auto& impl = thisObject.wrapped();
14688 RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<Storage>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.localStorage())));
14689}
14690
14691JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_localStorage, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
14692{
14693 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_localStorageGetter>(*lexicalGlobalObject, thisValue, attributeName);
14694}
14695
14696static inline JSValue jsDOMWindow_originGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
14697{
14698 auto& vm = JSC::getVM(&lexicalGlobalObject);
14699 auto throwScope = DECLARE_THROW_SCOPE(vm);
14700 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14701 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14702 if (!shouldAllowAccess)
14703 return jsUndefined();
14704 auto& impl = thisObject.wrapped();
14705 RELEASE_AND_RETURN(throwScope, (toJS<IDLUSVString>(lexicalGlobalObject, throwScope, impl.origin())));
14706}
14707
14708JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_origin, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
14709{
14710 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_originGetter>(*lexicalGlobalObject, thisValue, attributeName);
14711}
14712
14713static inline bool setJSDOMWindow_originSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
14714{
14715 auto& vm = JSC::getVM(&lexicalGlobalObject);
14716 auto throwScope = DECLARE_THROW_SCOPE(vm);
14717 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14718 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14719 if (!shouldAllowAccess)
14720 return false;
14721 // Shadowing a built-in property.
14722 return replaceStaticPropertySlot(vm, &thisObject, Identifier::fromString(vm, reinterpret_cast<const LChar*>("origin"), strlen("origin")), value);
14723}
14724
14725JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_origin, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
14726{
14727 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_originSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
14728}
14729
14730static inline JSValue jsDOMWindow_isSecureContextGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
14731{
14732 auto& vm = JSC::getVM(&lexicalGlobalObject);
14733 auto throwScope = DECLARE_THROW_SCOPE(vm);
14734 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14735 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14736 if (!shouldAllowAccess)
14737 return jsUndefined();
14738 auto& impl = thisObject.wrapped();
14739 RELEASE_AND_RETURN(throwScope, (toJS<IDLBoolean>(lexicalGlobalObject, throwScope, impl.isSecureContext())));
14740}
14741
14742JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_isSecureContext, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
14743{
14744 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_isSecureContextGetter>(*lexicalGlobalObject, thisValue, attributeName);
14745}
14746
14747static inline JSValue jsDOMWindow_cachesGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
14748{
14749 auto& vm = JSC::getVM(&lexicalGlobalObject);
14750 auto throwScope = DECLARE_THROW_SCOPE(vm);
14751 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14752 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14753 if (!shouldAllowAccess)
14754 return jsUndefined();
14755 auto* context = jsCast<JSDOMGlobalObject*>(&lexicalGlobalObject)->scriptExecutionContext();
14756 if (UNLIKELY(!context))
14757 return jsUndefined();
14758 auto& impl = thisObject.wrapped();
14759 RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<DOMCacheStorage>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, WebCore::WindowOrWorkerGlobalScopeCaches::caches(*context, impl))));
14760}
14761
14762JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_caches, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
14763{
14764 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_cachesGetter>(*lexicalGlobalObject, thisValue, attributeName);
14765}
14766
14767static inline JSValue jsDOMWindow_indexedDBGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
14768{
14769 auto& vm = JSC::getVM(&lexicalGlobalObject);
14770 auto throwScope = DECLARE_THROW_SCOPE(vm);
14771 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14772 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14773 if (!shouldAllowAccess)
14774 return jsUndefined();
14775 auto& impl = thisObject.wrapped();
14776 RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<IDBFactory>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, WebCore::WindowOrWorkerGlobalScopeIndexedDatabase::indexedDB(impl))));
14777}
14778
14779JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_indexedDB, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
14780{
14781 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_indexedDBGetter>(*lexicalGlobalObject, thisValue, attributeName);
14782}
14783
14784static inline JSValue jsDOMWindow_webkitIndexedDBGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
14785{
14786 auto& vm = JSC::getVM(&lexicalGlobalObject);
14787 auto throwScope = DECLARE_THROW_SCOPE(vm);
14788 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14789 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14790 if (!shouldAllowAccess)
14791 return jsUndefined();
14792 auto& impl = thisObject.wrapped();
14793 RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<IDBFactory>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, WebCore::WindowOrWorkerGlobalScopeIndexedDatabase::indexedDB(impl))));
14794}
14795
14796JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_webkitIndexedDB, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
14797{
14798 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_webkitIndexedDBGetter>(*lexicalGlobalObject, thisValue, attributeName);
14799}
14800
14801static inline JSValue jsDOMWindow_cryptoGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
14802{
14803 auto& vm = JSC::getVM(&lexicalGlobalObject);
14804 auto throwScope = DECLARE_THROW_SCOPE(vm);
14805 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14806 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14807 if (!shouldAllowAccess)
14808 return jsUndefined();
14809 auto& impl = thisObject.wrapped();
14810 RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<Crypto>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.crypto())));
14811}
14812
14813JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_crypto, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
14814{
14815 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_cryptoGetter>(*lexicalGlobalObject, thisValue, attributeName);
14816}
14817
14818static inline JSValue jsDOMWindow_performanceGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
14819{
14820 auto& vm = JSC::getVM(&lexicalGlobalObject);
14821 auto throwScope = DECLARE_THROW_SCOPE(vm);
14822 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14823 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14824 if (!shouldAllowAccess)
14825 return jsUndefined();
14826 auto& impl = thisObject.wrapped();
14827 RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<Performance>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.performance())));
14828}
14829
14830JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_performance, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
14831{
14832 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_performanceGetter>(*lexicalGlobalObject, thisValue, attributeName);
14833}
14834
14835static inline bool setJSDOMWindow_performanceSetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject, JSValue value)
14836{
14837 auto& vm = JSC::getVM(&lexicalGlobalObject);
14838 auto throwScope = DECLARE_THROW_SCOPE(vm);
14839 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14840 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14841 if (!shouldAllowAccess)
14842 return false;
14843 // Shadowing a built-in property.
14844 return replaceStaticPropertySlot(vm, &thisObject, Identifier::fromString(vm, reinterpret_cast<const LChar*>("performance"), strlen("performance")), value);
14845}
14846
14847JSC_DEFINE_CUSTOM_SETTER(setJSDOMWindow_performance, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
14848{
14849 return IDLAttribute<JSDOMWindow>::set<setJSDOMWindow_performanceSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
14850}
14851
14852static inline JSValue jsDOMWindow_sessionStorageGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
14853{
14854 auto& vm = JSC::getVM(&lexicalGlobalObject);
14855 auto throwScope = DECLARE_THROW_SCOPE(vm);
14856 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14857 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14858 if (!shouldAllowAccess)
14859 return jsUndefined();
14860 auto& impl = thisObject.wrapped();
14861 RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<Storage>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.sessionStorage())));
14862}
14863
14864JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_sessionStorage, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
14865{
14866 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_sessionStorageGetter>(*lexicalGlobalObject, thisValue, attributeName);
14867}
14868
14869#if ENABLE(TOUCH_EVENTS)
14870static inline JSValue jsDOMWindow_TouchConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
14871{
14872 auto& vm = JSC::getVM(&lexicalGlobalObject);
14873 auto throwScope = DECLARE_THROW_SCOPE(vm);
14874 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14875 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14876 if (!shouldAllowAccess)
14877 return jsUndefined();
14878 return JSTouch::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
14879}
14880
14881JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_TouchConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
14882{
14883 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_TouchConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
14884}
14885
14886#endif
14887
14888#if ENABLE(TOUCH_EVENTS)
14889static inline JSValue jsDOMWindow_TouchEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
14890{
14891 auto& vm = JSC::getVM(&lexicalGlobalObject);
14892 auto throwScope = DECLARE_THROW_SCOPE(vm);
14893 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14894 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14895 if (!shouldAllowAccess)
14896 return jsUndefined();
14897 return JSTouchEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
14898}
14899
14900JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_TouchEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
14901{
14902 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_TouchEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
14903}
14904
14905#endif
14906
14907#if ENABLE(TOUCH_EVENTS)
14908static inline JSValue jsDOMWindow_TouchListConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
14909{
14910 auto& vm = JSC::getVM(&lexicalGlobalObject);
14911 auto throwScope = DECLARE_THROW_SCOPE(vm);
14912 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14913 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14914 if (!shouldAllowAccess)
14915 return jsUndefined();
14916 return JSTouchList::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
14917}
14918
14919JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_TouchListConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
14920{
14921 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_TouchListConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
14922}
14923
14924#endif
14925
14926#if ENABLE(WIRELESS_PLAYBACK_TARGET)
14927static inline JSValue jsDOMWindow_WebKitPlaybackTargetAvailabilityEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
14928{
14929 auto& vm = JSC::getVM(&lexicalGlobalObject);
14930 auto throwScope = DECLARE_THROW_SCOPE(vm);
14931 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14932 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14933 if (!shouldAllowAccess)
14934 return jsUndefined();
14935 return JSWebKitPlaybackTargetAvailabilityEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
14936}
14937
14938JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WebKitPlaybackTargetAvailabilityEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
14939{
14940 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WebKitPlaybackTargetAvailabilityEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
14941}
14942
14943#endif
14944
14945#if ENABLE(APPLE_PAY)
14946static inline JSValue jsDOMWindow_ApplePayErrorConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
14947{
14948 auto& vm = JSC::getVM(&lexicalGlobalObject);
14949 auto throwScope = DECLARE_THROW_SCOPE(vm);
14950 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14951 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14952 if (!shouldAllowAccess)
14953 return jsUndefined();
14954 return JSApplePayError::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
14955}
14956
14957JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ApplePayErrorConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
14958{
14959 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ApplePayErrorConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
14960}
14961
14962#endif
14963
14964#if ENABLE(APPLE_PAY)
14965static inline JSValue jsDOMWindow_ApplePaySessionConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
14966{
14967 auto& vm = JSC::getVM(&lexicalGlobalObject);
14968 auto throwScope = DECLARE_THROW_SCOPE(vm);
14969 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14970 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14971 if (!shouldAllowAccess)
14972 return jsUndefined();
14973 return JSApplePaySession::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
14974}
14975
14976JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ApplePaySessionConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
14977{
14978 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ApplePaySessionConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
14979}
14980
14981#endif
14982
14983#if ENABLE(APPLE_PAY)
14984static inline JSValue jsDOMWindow_ApplePaySetupConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
14985{
14986 auto& vm = JSC::getVM(&lexicalGlobalObject);
14987 auto throwScope = DECLARE_THROW_SCOPE(vm);
14988 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
14989 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
14990 if (!shouldAllowAccess)
14991 return jsUndefined();
14992 return JSApplePaySetup::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
14993}
14994
14995JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ApplePaySetupConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
14996{
14997 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ApplePaySetupConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
14998}
14999
15000#endif
15001
15002#if ENABLE(APPLE_PAY)
15003static inline JSValue jsDOMWindow_ApplePaySetupFeatureConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15004{
15005 auto& vm = JSC::getVM(&lexicalGlobalObject);
15006 auto throwScope = DECLARE_THROW_SCOPE(vm);
15007 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15008 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15009 if (!shouldAllowAccess)
15010 return jsUndefined();
15011 return JSApplePaySetupFeature::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15012}
15013
15014JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ApplePaySetupFeatureConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15015{
15016 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ApplePaySetupFeatureConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15017}
15018
15019#endif
15020
15021static inline JSValue jsDOMWindow_ClipboardConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15022{
15023 auto& vm = JSC::getVM(&lexicalGlobalObject);
15024 auto throwScope = DECLARE_THROW_SCOPE(vm);
15025 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15026 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15027 if (!shouldAllowAccess)
15028 return jsUndefined();
15029 return JSClipboard::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15030}
15031
15032JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ClipboardConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15033{
15034 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ClipboardConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15035}
15036
15037static inline JSValue jsDOMWindow_ClipboardItemConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15038{
15039 auto& vm = JSC::getVM(&lexicalGlobalObject);
15040 auto throwScope = DECLARE_THROW_SCOPE(vm);
15041 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15042 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15043 if (!shouldAllowAccess)
15044 return jsUndefined();
15045 return JSClipboardItem::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15046}
15047
15048JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ClipboardItemConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15049{
15050 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ClipboardItemConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15051}
15052
15053static inline JSValue jsDOMWindow_CacheConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15054{
15055 auto& vm = JSC::getVM(&lexicalGlobalObject);
15056 auto throwScope = DECLARE_THROW_SCOPE(vm);
15057 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15058 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15059 if (!shouldAllowAccess)
15060 return jsUndefined();
15061 return JSDOMCache::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15062}
15063
15064JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CacheConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15065{
15066 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CacheConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15067}
15068
15069static inline JSValue jsDOMWindow_CacheStorageConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15070{
15071 auto& vm = JSC::getVM(&lexicalGlobalObject);
15072 auto throwScope = DECLARE_THROW_SCOPE(vm);
15073 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15074 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15075 if (!shouldAllowAccess)
15076 return jsUndefined();
15077 return JSDOMCacheStorage::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15078}
15079
15080JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CacheStorageConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15081{
15082 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CacheStorageConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15083}
15084
15085static inline JSValue jsDOMWindow_ContactsManagerConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15086{
15087 auto& vm = JSC::getVM(&lexicalGlobalObject);
15088 auto throwScope = DECLARE_THROW_SCOPE(vm);
15089 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15090 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15091 if (!shouldAllowAccess)
15092 return jsUndefined();
15093 return JSContactsManager::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15094}
15095
15096JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ContactsManagerConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15097{
15098 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ContactsManagerConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15099}
15100
15101#if ENABLE(WEB_AUTHN)
15102static inline JSValue jsDOMWindow_CredentialConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15103{
15104 auto& vm = JSC::getVM(&lexicalGlobalObject);
15105 auto throwScope = DECLARE_THROW_SCOPE(vm);
15106 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15107 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15108 if (!shouldAllowAccess)
15109 return jsUndefined();
15110 return JSBasicCredential::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15111}
15112
15113JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CredentialConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15114{
15115 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CredentialConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15116}
15117
15118#endif
15119
15120#if ENABLE(WEB_AUTHN)
15121static inline JSValue jsDOMWindow_CredentialsContainerConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15122{
15123 auto& vm = JSC::getVM(&lexicalGlobalObject);
15124 auto throwScope = DECLARE_THROW_SCOPE(vm);
15125 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15126 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15127 if (!shouldAllowAccess)
15128 return jsUndefined();
15129 return JSCredentialsContainer::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15130}
15131
15132JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CredentialsContainerConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15133{
15134 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CredentialsContainerConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15135}
15136
15137#endif
15138
15139#if ENABLE(ENCRYPTED_MEDIA)
15140static inline JSValue jsDOMWindow_MediaKeyMessageEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15141{
15142 auto& vm = JSC::getVM(&lexicalGlobalObject);
15143 auto throwScope = DECLARE_THROW_SCOPE(vm);
15144 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15145 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15146 if (!shouldAllowAccess)
15147 return jsUndefined();
15148 return JSMediaKeyMessageEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15149}
15150
15151JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MediaKeyMessageEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15152{
15153 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MediaKeyMessageEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15154}
15155
15156#endif
15157
15158#if ENABLE(ENCRYPTED_MEDIA)
15159static inline JSValue jsDOMWindow_MediaKeySessionConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15160{
15161 auto& vm = JSC::getVM(&lexicalGlobalObject);
15162 auto throwScope = DECLARE_THROW_SCOPE(vm);
15163 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15164 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15165 if (!shouldAllowAccess)
15166 return jsUndefined();
15167 return JSMediaKeySession::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15168}
15169
15170JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MediaKeySessionConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15171{
15172 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MediaKeySessionConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15173}
15174
15175#endif
15176
15177#if ENABLE(ENCRYPTED_MEDIA)
15178static inline JSValue jsDOMWindow_MediaKeyStatusMapConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15179{
15180 auto& vm = JSC::getVM(&lexicalGlobalObject);
15181 auto throwScope = DECLARE_THROW_SCOPE(vm);
15182 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15183 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15184 if (!shouldAllowAccess)
15185 return jsUndefined();
15186 return JSMediaKeyStatusMap::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15187}
15188
15189JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MediaKeyStatusMapConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15190{
15191 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MediaKeyStatusMapConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15192}
15193
15194#endif
15195
15196#if ENABLE(ENCRYPTED_MEDIA)
15197static inline JSValue jsDOMWindow_MediaKeySystemAccessConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15198{
15199 auto& vm = JSC::getVM(&lexicalGlobalObject);
15200 auto throwScope = DECLARE_THROW_SCOPE(vm);
15201 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15202 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15203 if (!shouldAllowAccess)
15204 return jsUndefined();
15205 return JSMediaKeySystemAccess::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15206}
15207
15208JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MediaKeySystemAccessConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15209{
15210 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MediaKeySystemAccessConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15211}
15212
15213#endif
15214
15215#if ENABLE(ENCRYPTED_MEDIA)
15216static inline JSValue jsDOMWindow_MediaKeysConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15217{
15218 auto& vm = JSC::getVM(&lexicalGlobalObject);
15219 auto throwScope = DECLARE_THROW_SCOPE(vm);
15220 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15221 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15222 if (!shouldAllowAccess)
15223 return jsUndefined();
15224 return JSMediaKeys::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15225}
15226
15227JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MediaKeysConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15228{
15229 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MediaKeysConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15230}
15231
15232#endif
15233
15234#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
15235static inline JSValue jsDOMWindow_WebKitMediaKeyMessageEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15236{
15237 auto& vm = JSC::getVM(&lexicalGlobalObject);
15238 auto throwScope = DECLARE_THROW_SCOPE(vm);
15239 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15240 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15241 if (!shouldAllowAccess)
15242 return jsUndefined();
15243 return JSWebKitMediaKeyMessageEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15244}
15245
15246JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WebKitMediaKeyMessageEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15247{
15248 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WebKitMediaKeyMessageEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15249}
15250
15251#endif
15252
15253#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
15254static inline JSValue jsDOMWindow_WebKitMediaKeyNeededEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15255{
15256 auto& vm = JSC::getVM(&lexicalGlobalObject);
15257 auto throwScope = DECLARE_THROW_SCOPE(vm);
15258 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15259 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15260 if (!shouldAllowAccess)
15261 return jsUndefined();
15262 return JSWebKitMediaKeyNeededEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15263}
15264
15265JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WebKitMediaKeyNeededEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15266{
15267 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WebKitMediaKeyNeededEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15268}
15269
15270#endif
15271
15272#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
15273static inline JSValue jsDOMWindow_WebKitMediaKeySessionConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15274{
15275 auto& vm = JSC::getVM(&lexicalGlobalObject);
15276 auto throwScope = DECLARE_THROW_SCOPE(vm);
15277 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15278 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15279 if (!shouldAllowAccess)
15280 return jsUndefined();
15281 return JSWebKitMediaKeySession::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15282}
15283
15284JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WebKitMediaKeySessionConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15285{
15286 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WebKitMediaKeySessionConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15287}
15288
15289#endif
15290
15291#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
15292static inline JSValue jsDOMWindow_WebKitMediaKeysConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15293{
15294 auto& vm = JSC::getVM(&lexicalGlobalObject);
15295 auto throwScope = DECLARE_THROW_SCOPE(vm);
15296 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15297 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15298 if (!shouldAllowAccess)
15299 return jsUndefined();
15300 return JSWebKitMediaKeys::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15301}
15302
15303JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WebKitMediaKeysConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15304{
15305 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WebKitMediaKeysConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15306}
15307
15308#endif
15309
15310static inline JSValue jsDOMWindow_FileSystemConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15311{
15312 auto& vm = JSC::getVM(&lexicalGlobalObject);
15313 auto throwScope = DECLARE_THROW_SCOPE(vm);
15314 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15315 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15316 if (!shouldAllowAccess)
15317 return jsUndefined();
15318 return JSDOMFileSystem::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15319}
15320
15321JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_FileSystemConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15322{
15323 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_FileSystemConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15324}
15325
15326static inline JSValue jsDOMWindow_FileSystemDirectoryEntryConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15327{
15328 auto& vm = JSC::getVM(&lexicalGlobalObject);
15329 auto throwScope = DECLARE_THROW_SCOPE(vm);
15330 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15331 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15332 if (!shouldAllowAccess)
15333 return jsUndefined();
15334 return JSFileSystemDirectoryEntry::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15335}
15336
15337JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_FileSystemDirectoryEntryConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15338{
15339 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_FileSystemDirectoryEntryConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15340}
15341
15342static inline JSValue jsDOMWindow_FileSystemDirectoryReaderConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15343{
15344 auto& vm = JSC::getVM(&lexicalGlobalObject);
15345 auto throwScope = DECLARE_THROW_SCOPE(vm);
15346 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15347 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15348 if (!shouldAllowAccess)
15349 return jsUndefined();
15350 return JSFileSystemDirectoryReader::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15351}
15352
15353JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_FileSystemDirectoryReaderConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15354{
15355 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_FileSystemDirectoryReaderConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15356}
15357
15358static inline JSValue jsDOMWindow_FileSystemEntryConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15359{
15360 auto& vm = JSC::getVM(&lexicalGlobalObject);
15361 auto throwScope = DECLARE_THROW_SCOPE(vm);
15362 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15363 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15364 if (!shouldAllowAccess)
15365 return jsUndefined();
15366 return JSFileSystemEntry::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15367}
15368
15369JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_FileSystemEntryConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15370{
15371 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_FileSystemEntryConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15372}
15373
15374static inline JSValue jsDOMWindow_FileSystemFileEntryConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15375{
15376 auto& vm = JSC::getVM(&lexicalGlobalObject);
15377 auto throwScope = DECLARE_THROW_SCOPE(vm);
15378 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15379 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15380 if (!shouldAllowAccess)
15381 return jsUndefined();
15382 return JSFileSystemFileEntry::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15383}
15384
15385JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_FileSystemFileEntryConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15386{
15387 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_FileSystemFileEntryConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15388}
15389
15390static inline JSValue jsDOMWindow_HeadersConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15391{
15392 auto& vm = JSC::getVM(&lexicalGlobalObject);
15393 auto throwScope = DECLARE_THROW_SCOPE(vm);
15394 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15395 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15396 if (!shouldAllowAccess)
15397 return jsUndefined();
15398 return JSFetchHeaders::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15399}
15400
15401JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HeadersConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15402{
15403 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HeadersConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15404}
15405
15406static inline JSValue jsDOMWindow_RequestConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15407{
15408 auto& vm = JSC::getVM(&lexicalGlobalObject);
15409 auto throwScope = DECLARE_THROW_SCOPE(vm);
15410 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15411 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15412 if (!shouldAllowAccess)
15413 return jsUndefined();
15414 return JSFetchRequest::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15415}
15416
15417JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_RequestConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15418{
15419 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_RequestConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15420}
15421
15422static inline JSValue jsDOMWindow_ResponseConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15423{
15424 auto& vm = JSC::getVM(&lexicalGlobalObject);
15425 auto throwScope = DECLARE_THROW_SCOPE(vm);
15426 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15427 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15428 if (!shouldAllowAccess)
15429 return jsUndefined();
15430 return JSFetchResponse::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15431}
15432
15433JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ResponseConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15434{
15435 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ResponseConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15436}
15437
15438#if ENABLE(GAMEPAD)
15439static inline JSValue jsDOMWindow_GamepadConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15440{
15441 auto& vm = JSC::getVM(&lexicalGlobalObject);
15442 auto throwScope = DECLARE_THROW_SCOPE(vm);
15443 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15444 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15445 if (!shouldAllowAccess)
15446 return jsUndefined();
15447 return JSGamepad::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15448}
15449
15450JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GamepadConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15451{
15452 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GamepadConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15453}
15454
15455#endif
15456
15457#if ENABLE(GAMEPAD)
15458static inline JSValue jsDOMWindow_GamepadButtonConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15459{
15460 auto& vm = JSC::getVM(&lexicalGlobalObject);
15461 auto throwScope = DECLARE_THROW_SCOPE(vm);
15462 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15463 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15464 if (!shouldAllowAccess)
15465 return jsUndefined();
15466 return JSGamepadButton::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15467}
15468
15469JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GamepadButtonConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15470{
15471 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GamepadButtonConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15472}
15473
15474#endif
15475
15476#if ENABLE(GAMEPAD)
15477static inline JSValue jsDOMWindow_GamepadEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15478{
15479 auto& vm = JSC::getVM(&lexicalGlobalObject);
15480 auto throwScope = DECLARE_THROW_SCOPE(vm);
15481 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15482 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15483 if (!shouldAllowAccess)
15484 return jsUndefined();
15485 return JSGamepadEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15486}
15487
15488JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GamepadEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15489{
15490 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GamepadEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15491}
15492
15493#endif
15494
15495#if ENABLE(GEOLOCATION)
15496static inline JSValue jsDOMWindow_GeolocationConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15497{
15498 auto& vm = JSC::getVM(&lexicalGlobalObject);
15499 auto throwScope = DECLARE_THROW_SCOPE(vm);
15500 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15501 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15502 if (!shouldAllowAccess)
15503 return jsUndefined();
15504 return JSGeolocation::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15505}
15506
15507JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GeolocationConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15508{
15509 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GeolocationConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15510}
15511
15512#endif
15513
15514#if ENABLE(GEOLOCATION)
15515static inline JSValue jsDOMWindow_GeolocationCoordinatesConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15516{
15517 auto& vm = JSC::getVM(&lexicalGlobalObject);
15518 auto throwScope = DECLARE_THROW_SCOPE(vm);
15519 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15520 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15521 if (!shouldAllowAccess)
15522 return jsUndefined();
15523 return JSGeolocationCoordinates::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15524}
15525
15526JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GeolocationCoordinatesConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15527{
15528 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GeolocationCoordinatesConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15529}
15530
15531#endif
15532
15533#if ENABLE(GEOLOCATION)
15534static inline JSValue jsDOMWindow_GeolocationPositionConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15535{
15536 auto& vm = JSC::getVM(&lexicalGlobalObject);
15537 auto throwScope = DECLARE_THROW_SCOPE(vm);
15538 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15539 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15540 if (!shouldAllowAccess)
15541 return jsUndefined();
15542 return JSGeolocationPosition::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15543}
15544
15545JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GeolocationPositionConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15546{
15547 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GeolocationPositionConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15548}
15549
15550#endif
15551
15552#if ENABLE(GEOLOCATION)
15553static inline JSValue jsDOMWindow_GeolocationPositionErrorConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15554{
15555 auto& vm = JSC::getVM(&lexicalGlobalObject);
15556 auto throwScope = DECLARE_THROW_SCOPE(vm);
15557 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15558 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15559 if (!shouldAllowAccess)
15560 return jsUndefined();
15561 return JSGeolocationPositionError::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15562}
15563
15564JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GeolocationPositionErrorConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15565{
15566 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GeolocationPositionErrorConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15567}
15568
15569#endif
15570
15571static inline JSValue jsDOMWindow_HighlightConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15572{
15573 auto& vm = JSC::getVM(&lexicalGlobalObject);
15574 auto throwScope = DECLARE_THROW_SCOPE(vm);
15575 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15576 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15577 if (!shouldAllowAccess)
15578 return jsUndefined();
15579 return JSHighlight::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15580}
15581
15582JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HighlightConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15583{
15584 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HighlightConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15585}
15586
15587static inline JSValue jsDOMWindow_HighlightRegisterConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15588{
15589 auto& vm = JSC::getVM(&lexicalGlobalObject);
15590 auto throwScope = DECLARE_THROW_SCOPE(vm);
15591 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15592 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15593 if (!shouldAllowAccess)
15594 return jsUndefined();
15595 return JSHighlightRegister::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15596}
15597
15598JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HighlightRegisterConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15599{
15600 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HighlightRegisterConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15601}
15602
15603static inline JSValue jsDOMWindow_IDBCursorConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15604{
15605 auto& vm = JSC::getVM(&lexicalGlobalObject);
15606 auto throwScope = DECLARE_THROW_SCOPE(vm);
15607 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15608 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15609 if (!shouldAllowAccess)
15610 return jsUndefined();
15611 return JSIDBCursor::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15612}
15613
15614JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_IDBCursorConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15615{
15616 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_IDBCursorConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15617}
15618
15619static inline JSValue jsDOMWindow_IDBCursorWithValueConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15620{
15621 auto& vm = JSC::getVM(&lexicalGlobalObject);
15622 auto throwScope = DECLARE_THROW_SCOPE(vm);
15623 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15624 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15625 if (!shouldAllowAccess)
15626 return jsUndefined();
15627 return JSIDBCursorWithValue::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15628}
15629
15630JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_IDBCursorWithValueConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15631{
15632 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_IDBCursorWithValueConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15633}
15634
15635static inline JSValue jsDOMWindow_IDBDatabaseConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15636{
15637 auto& vm = JSC::getVM(&lexicalGlobalObject);
15638 auto throwScope = DECLARE_THROW_SCOPE(vm);
15639 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15640 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15641 if (!shouldAllowAccess)
15642 return jsUndefined();
15643 return JSIDBDatabase::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15644}
15645
15646JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_IDBDatabaseConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15647{
15648 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_IDBDatabaseConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15649}
15650
15651static inline JSValue jsDOMWindow_IDBFactoryConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15652{
15653 auto& vm = JSC::getVM(&lexicalGlobalObject);
15654 auto throwScope = DECLARE_THROW_SCOPE(vm);
15655 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15656 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15657 if (!shouldAllowAccess)
15658 return jsUndefined();
15659 return JSIDBFactory::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15660}
15661
15662JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_IDBFactoryConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15663{
15664 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_IDBFactoryConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15665}
15666
15667static inline JSValue jsDOMWindow_IDBIndexConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15668{
15669 auto& vm = JSC::getVM(&lexicalGlobalObject);
15670 auto throwScope = DECLARE_THROW_SCOPE(vm);
15671 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15672 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15673 if (!shouldAllowAccess)
15674 return jsUndefined();
15675 return JSIDBIndex::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15676}
15677
15678JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_IDBIndexConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15679{
15680 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_IDBIndexConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15681}
15682
15683static inline JSValue jsDOMWindow_IDBKeyRangeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15684{
15685 auto& vm = JSC::getVM(&lexicalGlobalObject);
15686 auto throwScope = DECLARE_THROW_SCOPE(vm);
15687 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15688 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15689 if (!shouldAllowAccess)
15690 return jsUndefined();
15691 return JSIDBKeyRange::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15692}
15693
15694JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_IDBKeyRangeConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15695{
15696 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_IDBKeyRangeConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15697}
15698
15699static inline JSValue jsDOMWindow_IDBObjectStoreConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15700{
15701 auto& vm = JSC::getVM(&lexicalGlobalObject);
15702 auto throwScope = DECLARE_THROW_SCOPE(vm);
15703 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15704 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15705 if (!shouldAllowAccess)
15706 return jsUndefined();
15707 return JSIDBObjectStore::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15708}
15709
15710JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_IDBObjectStoreConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15711{
15712 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_IDBObjectStoreConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15713}
15714
15715static inline JSValue jsDOMWindow_IDBOpenDBRequestConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15716{
15717 auto& vm = JSC::getVM(&lexicalGlobalObject);
15718 auto throwScope = DECLARE_THROW_SCOPE(vm);
15719 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15720 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15721 if (!shouldAllowAccess)
15722 return jsUndefined();
15723 return JSIDBOpenDBRequest::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15724}
15725
15726JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_IDBOpenDBRequestConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15727{
15728 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_IDBOpenDBRequestConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15729}
15730
15731static inline JSValue jsDOMWindow_IDBRequestConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15732{
15733 auto& vm = JSC::getVM(&lexicalGlobalObject);
15734 auto throwScope = DECLARE_THROW_SCOPE(vm);
15735 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15736 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15737 if (!shouldAllowAccess)
15738 return jsUndefined();
15739 return JSIDBRequest::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15740}
15741
15742JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_IDBRequestConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15743{
15744 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_IDBRequestConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15745}
15746
15747static inline JSValue jsDOMWindow_IDBTransactionConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15748{
15749 auto& vm = JSC::getVM(&lexicalGlobalObject);
15750 auto throwScope = DECLARE_THROW_SCOPE(vm);
15751 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15752 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15753 if (!shouldAllowAccess)
15754 return jsUndefined();
15755 return JSIDBTransaction::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15756}
15757
15758JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_IDBTransactionConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15759{
15760 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_IDBTransactionConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15761}
15762
15763static inline JSValue jsDOMWindow_IDBVersionChangeEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15764{
15765 auto& vm = JSC::getVM(&lexicalGlobalObject);
15766 auto throwScope = DECLARE_THROW_SCOPE(vm);
15767 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15768 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15769 if (!shouldAllowAccess)
15770 return jsUndefined();
15771 return JSIDBVersionChangeEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15772}
15773
15774JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_IDBVersionChangeEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15775{
15776 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_IDBVersionChangeEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15777}
15778
15779static inline JSValue jsDOMWindow_MediaCapabilitiesConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15780{
15781 auto& vm = JSC::getVM(&lexicalGlobalObject);
15782 auto throwScope = DECLARE_THROW_SCOPE(vm);
15783 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15784 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15785 if (!shouldAllowAccess)
15786 return jsUndefined();
15787 return JSMediaCapabilities::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15788}
15789
15790JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MediaCapabilitiesConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15791{
15792 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MediaCapabilitiesConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15793}
15794
15795#if ENABLE(MEDIA_STREAM)
15796static inline JSValue jsDOMWindow_BlobEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15797{
15798 auto& vm = JSC::getVM(&lexicalGlobalObject);
15799 auto throwScope = DECLARE_THROW_SCOPE(vm);
15800 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15801 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15802 if (!shouldAllowAccess)
15803 return jsUndefined();
15804 return JSBlobEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15805}
15806
15807JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_BlobEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15808{
15809 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_BlobEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15810}
15811
15812#endif
15813
15814#if ENABLE(MEDIA_STREAM)
15815static inline JSValue jsDOMWindow_MediaRecorderConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15816{
15817 auto& vm = JSC::getVM(&lexicalGlobalObject);
15818 auto throwScope = DECLARE_THROW_SCOPE(vm);
15819 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15820 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15821 if (!shouldAllowAccess)
15822 return jsUndefined();
15823 return JSMediaRecorder::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15824}
15825
15826JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MediaRecorderConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15827{
15828 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MediaRecorderConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15829}
15830
15831#endif
15832
15833#if ENABLE(MEDIA_STREAM)
15834static inline JSValue jsDOMWindow_MediaRecorderErrorEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15835{
15836 auto& vm = JSC::getVM(&lexicalGlobalObject);
15837 auto throwScope = DECLARE_THROW_SCOPE(vm);
15838 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15839 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15840 if (!shouldAllowAccess)
15841 return jsUndefined();
15842 return JSMediaRecorderErrorEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15843}
15844
15845JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MediaRecorderErrorEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15846{
15847 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MediaRecorderErrorEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15848}
15849
15850#endif
15851
15852#if ENABLE(MEDIA_SESSION)
15853static inline JSValue jsDOMWindow_MediaMetadataConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15854{
15855 auto& vm = JSC::getVM(&lexicalGlobalObject);
15856 auto throwScope = DECLARE_THROW_SCOPE(vm);
15857 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15858 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15859 if (!shouldAllowAccess)
15860 return jsUndefined();
15861 return JSMediaMetadata::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15862}
15863
15864JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MediaMetadataConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15865{
15866 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MediaMetadataConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15867}
15868
15869#endif
15870
15871#if ENABLE(MEDIA_SESSION)
15872static inline JSValue jsDOMWindow_MediaSessionConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15873{
15874 auto& vm = JSC::getVM(&lexicalGlobalObject);
15875 auto throwScope = DECLARE_THROW_SCOPE(vm);
15876 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15877 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15878 if (!shouldAllowAccess)
15879 return jsUndefined();
15880 return JSMediaSession::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15881}
15882
15883JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MediaSessionConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15884{
15885 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MediaSessionConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15886}
15887
15888#endif
15889
15890#if ENABLE(MEDIA_SESSION_COORDINATOR)
15891static inline JSValue jsDOMWindow_MediaSessionCoordinatorConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15892{
15893 auto& vm = JSC::getVM(&lexicalGlobalObject);
15894 auto throwScope = DECLARE_THROW_SCOPE(vm);
15895 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15896 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15897 if (!shouldAllowAccess)
15898 return jsUndefined();
15899 return JSMediaSessionCoordinator::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15900}
15901
15902JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MediaSessionCoordinatorConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15903{
15904 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MediaSessionCoordinatorConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15905}
15906
15907#endif
15908
15909#if ENABLE(MEDIA_SOURCE)
15910static inline JSValue jsDOMWindow_MediaSourceConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15911{
15912 auto& vm = JSC::getVM(&lexicalGlobalObject);
15913 auto throwScope = DECLARE_THROW_SCOPE(vm);
15914 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15915 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15916 if (!shouldAllowAccess)
15917 return jsUndefined();
15918 return JSMediaSource::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15919}
15920
15921JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MediaSourceConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15922{
15923 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MediaSourceConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15924}
15925
15926#endif
15927
15928#if ENABLE(MEDIA_SOURCE)
15929static inline JSValue jsDOMWindow_SourceBufferConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15930{
15931 auto& vm = JSC::getVM(&lexicalGlobalObject);
15932 auto throwScope = DECLARE_THROW_SCOPE(vm);
15933 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15934 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15935 if (!shouldAllowAccess)
15936 return jsUndefined();
15937 return JSSourceBuffer::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15938}
15939
15940JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SourceBufferConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15941{
15942 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SourceBufferConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15943}
15944
15945#endif
15946
15947#if ENABLE(MEDIA_SOURCE)
15948static inline JSValue jsDOMWindow_SourceBufferListConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15949{
15950 auto& vm = JSC::getVM(&lexicalGlobalObject);
15951 auto throwScope = DECLARE_THROW_SCOPE(vm);
15952 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15953 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15954 if (!shouldAllowAccess)
15955 return jsUndefined();
15956 return JSSourceBufferList::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15957}
15958
15959JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SourceBufferListConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15960{
15961 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SourceBufferListConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15962}
15963
15964#endif
15965
15966#if ENABLE(MEDIA_STREAM)
15967static inline JSValue jsDOMWindow_CanvasCaptureMediaStreamTrackConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15968{
15969 auto& vm = JSC::getVM(&lexicalGlobalObject);
15970 auto throwScope = DECLARE_THROW_SCOPE(vm);
15971 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15972 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15973 if (!shouldAllowAccess)
15974 return jsUndefined();
15975 return JSCanvasCaptureMediaStreamTrack::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15976}
15977
15978JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CanvasCaptureMediaStreamTrackConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15979{
15980 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CanvasCaptureMediaStreamTrackConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
15981}
15982
15983#endif
15984
15985#if ENABLE(MEDIA_STREAM)
15986static inline JSValue jsDOMWindow_MediaDeviceInfoConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
15987{
15988 auto& vm = JSC::getVM(&lexicalGlobalObject);
15989 auto throwScope = DECLARE_THROW_SCOPE(vm);
15990 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
15991 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
15992 if (!shouldAllowAccess)
15993 return jsUndefined();
15994 return JSMediaDeviceInfo::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
15995}
15996
15997JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MediaDeviceInfoConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
15998{
15999 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MediaDeviceInfoConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16000}
16001
16002#endif
16003
16004#if ENABLE(MEDIA_STREAM)
16005static inline JSValue jsDOMWindow_MediaDevicesConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16006{
16007 auto& vm = JSC::getVM(&lexicalGlobalObject);
16008 auto throwScope = DECLARE_THROW_SCOPE(vm);
16009 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16010 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16011 if (!shouldAllowAccess)
16012 return jsUndefined();
16013 return JSMediaDevices::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16014}
16015
16016JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MediaDevicesConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16017{
16018 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MediaDevicesConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16019}
16020
16021#endif
16022
16023#if ENABLE(MEDIA_STREAM)
16024static inline JSValue jsDOMWindow_MediaStreamConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16025{
16026 auto& vm = JSC::getVM(&lexicalGlobalObject);
16027 auto throwScope = DECLARE_THROW_SCOPE(vm);
16028 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16029 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16030 if (!shouldAllowAccess)
16031 return jsUndefined();
16032 return JSMediaStream::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16033}
16034
16035JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MediaStreamConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16036{
16037 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MediaStreamConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16038}
16039
16040#endif
16041
16042#if ENABLE(MEDIA_STREAM)
16043static inline JSValue jsDOMWindow_MediaStreamTrackConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16044{
16045 auto& vm = JSC::getVM(&lexicalGlobalObject);
16046 auto throwScope = DECLARE_THROW_SCOPE(vm);
16047 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16048 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16049 if (!shouldAllowAccess)
16050 return jsUndefined();
16051 return JSMediaStreamTrack::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16052}
16053
16054JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MediaStreamTrackConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16055{
16056 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MediaStreamTrackConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16057}
16058
16059#endif
16060
16061#if ENABLE(MEDIA_STREAM)
16062static inline JSValue jsDOMWindow_MediaStreamTrackEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16063{
16064 auto& vm = JSC::getVM(&lexicalGlobalObject);
16065 auto throwScope = DECLARE_THROW_SCOPE(vm);
16066 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16067 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16068 if (!shouldAllowAccess)
16069 return jsUndefined();
16070 return JSMediaStreamTrackEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16071}
16072
16073JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MediaStreamTrackEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16074{
16075 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MediaStreamTrackEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16076}
16077
16078#endif
16079
16080#if ENABLE(MEDIA_STREAM)
16081static inline JSValue jsDOMWindow_OverconstrainedErrorConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16082{
16083 auto& vm = JSC::getVM(&lexicalGlobalObject);
16084 auto throwScope = DECLARE_THROW_SCOPE(vm);
16085 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16086 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16087 if (!shouldAllowAccess)
16088 return jsUndefined();
16089 return JSOverconstrainedError::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16090}
16091
16092JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_OverconstrainedErrorConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16093{
16094 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_OverconstrainedErrorConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16095}
16096
16097#endif
16098
16099#if ENABLE(MEDIA_STREAM)
16100static inline JSValue jsDOMWindow_OverconstrainedErrorEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16101{
16102 auto& vm = JSC::getVM(&lexicalGlobalObject);
16103 auto throwScope = DECLARE_THROW_SCOPE(vm);
16104 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16105 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16106 if (!shouldAllowAccess)
16107 return jsUndefined();
16108 return JSOverconstrainedErrorEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16109}
16110
16111JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_OverconstrainedErrorEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16112{
16113 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_OverconstrainedErrorEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16114}
16115
16116#endif
16117
16118#if ENABLE(WEB_RTC)
16119static inline JSValue jsDOMWindow_RTCCertificateConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16120{
16121 auto& vm = JSC::getVM(&lexicalGlobalObject);
16122 auto throwScope = DECLARE_THROW_SCOPE(vm);
16123 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16124 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16125 if (!shouldAllowAccess)
16126 return jsUndefined();
16127 return JSRTCCertificate::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16128}
16129
16130JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_RTCCertificateConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16131{
16132 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_RTCCertificateConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16133}
16134
16135#endif
16136
16137#if ENABLE(WEB_RTC)
16138static inline JSValue jsDOMWindow_RTCDTMFSenderConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16139{
16140 auto& vm = JSC::getVM(&lexicalGlobalObject);
16141 auto throwScope = DECLARE_THROW_SCOPE(vm);
16142 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16143 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16144 if (!shouldAllowAccess)
16145 return jsUndefined();
16146 return JSRTCDTMFSender::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16147}
16148
16149JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_RTCDTMFSenderConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16150{
16151 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_RTCDTMFSenderConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16152}
16153
16154#endif
16155
16156#if ENABLE(WEB_RTC)
16157static inline JSValue jsDOMWindow_RTCDTMFToneChangeEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16158{
16159 auto& vm = JSC::getVM(&lexicalGlobalObject);
16160 auto throwScope = DECLARE_THROW_SCOPE(vm);
16161 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16162 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16163 if (!shouldAllowAccess)
16164 return jsUndefined();
16165 return JSRTCDTMFToneChangeEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16166}
16167
16168JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_RTCDTMFToneChangeEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16169{
16170 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_RTCDTMFToneChangeEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16171}
16172
16173#endif
16174
16175#if ENABLE(WEB_RTC)
16176static inline JSValue jsDOMWindow_RTCDataChannelConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16177{
16178 auto& vm = JSC::getVM(&lexicalGlobalObject);
16179 auto throwScope = DECLARE_THROW_SCOPE(vm);
16180 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16181 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16182 if (!shouldAllowAccess)
16183 return jsUndefined();
16184 return JSRTCDataChannel::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16185}
16186
16187JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_RTCDataChannelConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16188{
16189 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_RTCDataChannelConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16190}
16191
16192#endif
16193
16194#if ENABLE(WEB_RTC)
16195static inline JSValue jsDOMWindow_RTCDataChannelEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16196{
16197 auto& vm = JSC::getVM(&lexicalGlobalObject);
16198 auto throwScope = DECLARE_THROW_SCOPE(vm);
16199 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16200 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16201 if (!shouldAllowAccess)
16202 return jsUndefined();
16203 return JSRTCDataChannelEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16204}
16205
16206JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_RTCDataChannelEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16207{
16208 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_RTCDataChannelEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16209}
16210
16211#endif
16212
16213#if ENABLE(WEB_RTC)
16214static inline JSValue jsDOMWindow_RTCIceCandidateConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16215{
16216 auto& vm = JSC::getVM(&lexicalGlobalObject);
16217 auto throwScope = DECLARE_THROW_SCOPE(vm);
16218 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16219 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16220 if (!shouldAllowAccess)
16221 return jsUndefined();
16222 return JSRTCIceCandidate::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16223}
16224
16225JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_RTCIceCandidateConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16226{
16227 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_RTCIceCandidateConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16228}
16229
16230#endif
16231
16232#if ENABLE(WEB_RTC)
16233static inline JSValue jsDOMWindow_RTCIceTransportConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16234{
16235 auto& vm = JSC::getVM(&lexicalGlobalObject);
16236 auto throwScope = DECLARE_THROW_SCOPE(vm);
16237 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16238 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16239 if (!shouldAllowAccess)
16240 return jsUndefined();
16241 return JSRTCIceTransport::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16242}
16243
16244JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_RTCIceTransportConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16245{
16246 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_RTCIceTransportConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16247}
16248
16249#endif
16250
16251#if ENABLE(WEB_RTC)
16252static inline JSValue jsDOMWindow_RTCPeerConnectionConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16253{
16254 auto& vm = JSC::getVM(&lexicalGlobalObject);
16255 auto throwScope = DECLARE_THROW_SCOPE(vm);
16256 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16257 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16258 if (!shouldAllowAccess)
16259 return jsUndefined();
16260 return JSRTCPeerConnection::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16261}
16262
16263JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_RTCPeerConnectionConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16264{
16265 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_RTCPeerConnectionConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16266}
16267
16268#endif
16269
16270#if ENABLE(WEB_RTC)
16271static inline JSValue jsDOMWindow_RTCPeerConnectionIceErrorEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16272{
16273 auto& vm = JSC::getVM(&lexicalGlobalObject);
16274 auto throwScope = DECLARE_THROW_SCOPE(vm);
16275 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16276 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16277 if (!shouldAllowAccess)
16278 return jsUndefined();
16279 return JSRTCPeerConnectionIceErrorEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16280}
16281
16282JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_RTCPeerConnectionIceErrorEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16283{
16284 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_RTCPeerConnectionIceErrorEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16285}
16286
16287#endif
16288
16289#if ENABLE(WEB_RTC)
16290static inline JSValue jsDOMWindow_RTCPeerConnectionIceEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16291{
16292 auto& vm = JSC::getVM(&lexicalGlobalObject);
16293 auto throwScope = DECLARE_THROW_SCOPE(vm);
16294 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16295 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16296 if (!shouldAllowAccess)
16297 return jsUndefined();
16298 return JSRTCPeerConnectionIceEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16299}
16300
16301JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_RTCPeerConnectionIceEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16302{
16303 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_RTCPeerConnectionIceEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16304}
16305
16306#endif
16307
16308#if ENABLE(WEB_RTC)
16309static inline JSValue jsDOMWindow_RTCRtpReceiverConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16310{
16311 auto& vm = JSC::getVM(&lexicalGlobalObject);
16312 auto throwScope = DECLARE_THROW_SCOPE(vm);
16313 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16314 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16315 if (!shouldAllowAccess)
16316 return jsUndefined();
16317 return JSRTCRtpReceiver::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16318}
16319
16320JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_RTCRtpReceiverConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16321{
16322 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_RTCRtpReceiverConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16323}
16324
16325#endif
16326
16327#if ENABLE(WEB_RTC)
16328static inline JSValue jsDOMWindow_SFrameTransformConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16329{
16330 auto& vm = JSC::getVM(&lexicalGlobalObject);
16331 auto throwScope = DECLARE_THROW_SCOPE(vm);
16332 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16333 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16334 if (!shouldAllowAccess)
16335 return jsUndefined();
16336 return JSRTCRtpSFrameTransform::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16337}
16338
16339JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SFrameTransformConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16340{
16341 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SFrameTransformConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16342}
16343
16344#endif
16345
16346#if ENABLE(WEB_RTC)
16347static inline JSValue jsDOMWindow_RTCRtpScriptTransformConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16348{
16349 auto& vm = JSC::getVM(&lexicalGlobalObject);
16350 auto throwScope = DECLARE_THROW_SCOPE(vm);
16351 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16352 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16353 if (!shouldAllowAccess)
16354 return jsUndefined();
16355 return JSRTCRtpScriptTransform::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16356}
16357
16358JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_RTCRtpScriptTransformConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16359{
16360 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_RTCRtpScriptTransformConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16361}
16362
16363#endif
16364
16365#if ENABLE(WEB_RTC)
16366static inline JSValue jsDOMWindow_RTCRtpSenderConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16367{
16368 auto& vm = JSC::getVM(&lexicalGlobalObject);
16369 auto throwScope = DECLARE_THROW_SCOPE(vm);
16370 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16371 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16372 if (!shouldAllowAccess)
16373 return jsUndefined();
16374 return JSRTCRtpSender::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16375}
16376
16377JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_RTCRtpSenderConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16378{
16379 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_RTCRtpSenderConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16380}
16381
16382#endif
16383
16384#if ENABLE(WEB_RTC)
16385static inline JSValue jsDOMWindow_RTCRtpTransceiverConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16386{
16387 auto& vm = JSC::getVM(&lexicalGlobalObject);
16388 auto throwScope = DECLARE_THROW_SCOPE(vm);
16389 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16390 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16391 if (!shouldAllowAccess)
16392 return jsUndefined();
16393 return JSRTCRtpTransceiver::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16394}
16395
16396JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_RTCRtpTransceiverConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16397{
16398 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_RTCRtpTransceiverConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16399}
16400
16401#endif
16402
16403#if ENABLE(WEB_RTC)
16404static inline JSValue jsDOMWindow_RTCSessionDescriptionConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16405{
16406 auto& vm = JSC::getVM(&lexicalGlobalObject);
16407 auto throwScope = DECLARE_THROW_SCOPE(vm);
16408 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16409 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16410 if (!shouldAllowAccess)
16411 return jsUndefined();
16412 return JSRTCSessionDescription::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16413}
16414
16415JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_RTCSessionDescriptionConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16416{
16417 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_RTCSessionDescriptionConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16418}
16419
16420#endif
16421
16422#if ENABLE(WEB_RTC)
16423static inline JSValue jsDOMWindow_RTCStatsReportConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16424{
16425 auto& vm = JSC::getVM(&lexicalGlobalObject);
16426 auto throwScope = DECLARE_THROW_SCOPE(vm);
16427 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16428 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16429 if (!shouldAllowAccess)
16430 return jsUndefined();
16431 return JSRTCStatsReport::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16432}
16433
16434JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_RTCStatsReportConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16435{
16436 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_RTCStatsReportConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16437}
16438
16439#endif
16440
16441#if ENABLE(WEB_RTC)
16442static inline JSValue jsDOMWindow_RTCTrackEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16443{
16444 auto& vm = JSC::getVM(&lexicalGlobalObject);
16445 auto throwScope = DECLARE_THROW_SCOPE(vm);
16446 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16447 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16448 if (!shouldAllowAccess)
16449 return jsUndefined();
16450 return JSRTCTrackEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16451}
16452
16453JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_RTCTrackEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16454{
16455 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_RTCTrackEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16456}
16457
16458#endif
16459
16460#if ENABLE(MODEL_ELEMENT)
16461static inline JSValue jsDOMWindow_HTMLModelElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16462{
16463 auto& vm = JSC::getVM(&lexicalGlobalObject);
16464 auto throwScope = DECLARE_THROW_SCOPE(vm);
16465 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16466 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16467 if (!shouldAllowAccess)
16468 return jsUndefined();
16469 return JSHTMLModelElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16470}
16471
16472JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLModelElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16473{
16474 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLModelElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16475}
16476
16477#endif
16478
16479#if ENABLE(NOTIFICATIONS)
16480static inline JSValue jsDOMWindow_NotificationConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16481{
16482 auto& vm = JSC::getVM(&lexicalGlobalObject);
16483 auto throwScope = DECLARE_THROW_SCOPE(vm);
16484 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16485 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16486 if (!shouldAllowAccess)
16487 return jsUndefined();
16488 return JSNotification::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16489}
16490
16491JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_NotificationConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16492{
16493 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_NotificationConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16494}
16495
16496#endif
16497
16498#if ENABLE(PAYMENT_REQUEST)
16499static inline JSValue jsDOMWindow_MerchantValidationEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16500{
16501 auto& vm = JSC::getVM(&lexicalGlobalObject);
16502 auto throwScope = DECLARE_THROW_SCOPE(vm);
16503 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16504 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16505 if (!shouldAllowAccess)
16506 return jsUndefined();
16507 return JSMerchantValidationEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16508}
16509
16510JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MerchantValidationEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16511{
16512 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MerchantValidationEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16513}
16514
16515#endif
16516
16517#if ENABLE(PAYMENT_REQUEST)
16518static inline JSValue jsDOMWindow_PaymentAddressConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16519{
16520 auto& vm = JSC::getVM(&lexicalGlobalObject);
16521 auto throwScope = DECLARE_THROW_SCOPE(vm);
16522 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16523 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16524 if (!shouldAllowAccess)
16525 return jsUndefined();
16526 return JSPaymentAddress::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16527}
16528
16529JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_PaymentAddressConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16530{
16531 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_PaymentAddressConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16532}
16533
16534#endif
16535
16536#if ENABLE(PAYMENT_REQUEST)
16537static inline JSValue jsDOMWindow_PaymentMethodChangeEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16538{
16539 auto& vm = JSC::getVM(&lexicalGlobalObject);
16540 auto throwScope = DECLARE_THROW_SCOPE(vm);
16541 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16542 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16543 if (!shouldAllowAccess)
16544 return jsUndefined();
16545 return JSPaymentMethodChangeEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16546}
16547
16548JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_PaymentMethodChangeEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16549{
16550 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_PaymentMethodChangeEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16551}
16552
16553#endif
16554
16555#if ENABLE(PAYMENT_REQUEST)
16556static inline JSValue jsDOMWindow_PaymentRequestConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16557{
16558 auto& vm = JSC::getVM(&lexicalGlobalObject);
16559 auto throwScope = DECLARE_THROW_SCOPE(vm);
16560 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16561 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16562 if (!shouldAllowAccess)
16563 return jsUndefined();
16564 return JSPaymentRequest::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16565}
16566
16567JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_PaymentRequestConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16568{
16569 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_PaymentRequestConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16570}
16571
16572#endif
16573
16574#if ENABLE(PAYMENT_REQUEST)
16575static inline JSValue jsDOMWindow_PaymentRequestUpdateEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16576{
16577 auto& vm = JSC::getVM(&lexicalGlobalObject);
16578 auto throwScope = DECLARE_THROW_SCOPE(vm);
16579 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16580 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16581 if (!shouldAllowAccess)
16582 return jsUndefined();
16583 return JSPaymentRequestUpdateEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16584}
16585
16586JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_PaymentRequestUpdateEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16587{
16588 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_PaymentRequestUpdateEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16589}
16590
16591#endif
16592
16593#if ENABLE(PAYMENT_REQUEST)
16594static inline JSValue jsDOMWindow_PaymentResponseConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16595{
16596 auto& vm = JSC::getVM(&lexicalGlobalObject);
16597 auto throwScope = DECLARE_THROW_SCOPE(vm);
16598 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16599 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16600 if (!shouldAllowAccess)
16601 return jsUndefined();
16602 return JSPaymentResponse::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16603}
16604
16605JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_PaymentResponseConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16606{
16607 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_PaymentResponseConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16608}
16609
16610#endif
16611
16612#if ENABLE(PICTURE_IN_PICTURE_API)
16613static inline JSValue jsDOMWindow_EnterPictureInPictureEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16614{
16615 auto& vm = JSC::getVM(&lexicalGlobalObject);
16616 auto throwScope = DECLARE_THROW_SCOPE(vm);
16617 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16618 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16619 if (!shouldAllowAccess)
16620 return jsUndefined();
16621 return JSEnterPictureInPictureEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16622}
16623
16624JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_EnterPictureInPictureEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16625{
16626 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_EnterPictureInPictureEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16627}
16628
16629#endif
16630
16631#if ENABLE(PICTURE_IN_PICTURE_API)
16632static inline JSValue jsDOMWindow_PictureInPictureWindowConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16633{
16634 auto& vm = JSC::getVM(&lexicalGlobalObject);
16635 auto throwScope = DECLARE_THROW_SCOPE(vm);
16636 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16637 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16638 if (!shouldAllowAccess)
16639 return jsUndefined();
16640 return JSPictureInPictureWindow::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16641}
16642
16643JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_PictureInPictureWindowConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16644{
16645 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_PictureInPictureWindowConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16646}
16647
16648#endif
16649
16650#if ENABLE(WIRELESS_PLAYBACK_TARGET)
16651static inline JSValue jsDOMWindow_RemotePlaybackConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16652{
16653 auto& vm = JSC::getVM(&lexicalGlobalObject);
16654 auto throwScope = DECLARE_THROW_SCOPE(vm);
16655 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16656 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16657 if (!shouldAllowAccess)
16658 return jsUndefined();
16659 return JSRemotePlayback::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16660}
16661
16662JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_RemotePlaybackConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16663{
16664 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_RemotePlaybackConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16665}
16666
16667#endif
16668
16669static inline JSValue jsDOMWindow_webkitSpeechRecognitionConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16670{
16671 auto& vm = JSC::getVM(&lexicalGlobalObject);
16672 auto throwScope = DECLARE_THROW_SCOPE(vm);
16673 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16674 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16675 if (!shouldAllowAccess)
16676 return jsUndefined();
16677 return JSSpeechRecognition::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16678}
16679
16680JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_webkitSpeechRecognitionConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16681{
16682 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_webkitSpeechRecognitionConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16683}
16684
16685static inline JSValue jsDOMWindow_SpeechRecognitionAlternativeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16686{
16687 auto& vm = JSC::getVM(&lexicalGlobalObject);
16688 auto throwScope = DECLARE_THROW_SCOPE(vm);
16689 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16690 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16691 if (!shouldAllowAccess)
16692 return jsUndefined();
16693 return JSSpeechRecognitionAlternative::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16694}
16695
16696JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SpeechRecognitionAlternativeConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16697{
16698 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SpeechRecognitionAlternativeConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16699}
16700
16701static inline JSValue jsDOMWindow_SpeechRecognitionErrorEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16702{
16703 auto& vm = JSC::getVM(&lexicalGlobalObject);
16704 auto throwScope = DECLARE_THROW_SCOPE(vm);
16705 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16706 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16707 if (!shouldAllowAccess)
16708 return jsUndefined();
16709 return JSSpeechRecognitionErrorEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16710}
16711
16712JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SpeechRecognitionErrorEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16713{
16714 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SpeechRecognitionErrorEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16715}
16716
16717static inline JSValue jsDOMWindow_SpeechRecognitionEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16718{
16719 auto& vm = JSC::getVM(&lexicalGlobalObject);
16720 auto throwScope = DECLARE_THROW_SCOPE(vm);
16721 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16722 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16723 if (!shouldAllowAccess)
16724 return jsUndefined();
16725 return JSSpeechRecognitionEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16726}
16727
16728JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SpeechRecognitionEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16729{
16730 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SpeechRecognitionEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16731}
16732
16733static inline JSValue jsDOMWindow_SpeechRecognitionResultConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16734{
16735 auto& vm = JSC::getVM(&lexicalGlobalObject);
16736 auto throwScope = DECLARE_THROW_SCOPE(vm);
16737 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16738 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16739 if (!shouldAllowAccess)
16740 return jsUndefined();
16741 return JSSpeechRecognitionResult::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16742}
16743
16744JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SpeechRecognitionResultConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16745{
16746 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SpeechRecognitionResultConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16747}
16748
16749static inline JSValue jsDOMWindow_SpeechRecognitionResultListConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16750{
16751 auto& vm = JSC::getVM(&lexicalGlobalObject);
16752 auto throwScope = DECLARE_THROW_SCOPE(vm);
16753 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16754 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16755 if (!shouldAllowAccess)
16756 return jsUndefined();
16757 return JSSpeechRecognitionResultList::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16758}
16759
16760JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SpeechRecognitionResultListConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16761{
16762 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SpeechRecognitionResultListConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16763}
16764
16765#if ENABLE(SPEECH_SYNTHESIS)
16766static inline JSValue jsDOMWindow_SpeechSynthesisEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16767{
16768 auto& vm = JSC::getVM(&lexicalGlobalObject);
16769 auto throwScope = DECLARE_THROW_SCOPE(vm);
16770 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16771 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16772 if (!shouldAllowAccess)
16773 return jsUndefined();
16774 return JSSpeechSynthesisEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16775}
16776
16777JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SpeechSynthesisEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16778{
16779 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SpeechSynthesisEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16780}
16781
16782#endif
16783
16784#if ENABLE(SPEECH_SYNTHESIS)
16785static inline JSValue jsDOMWindow_SpeechSynthesisUtteranceConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16786{
16787 auto& vm = JSC::getVM(&lexicalGlobalObject);
16788 auto throwScope = DECLARE_THROW_SCOPE(vm);
16789 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16790 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16791 if (!shouldAllowAccess)
16792 return jsUndefined();
16793 return JSSpeechSynthesisUtterance::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16794}
16795
16796JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SpeechSynthesisUtteranceConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16797{
16798 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SpeechSynthesisUtteranceConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16799}
16800
16801#endif
16802
16803static inline JSValue jsDOMWindow_ByteLengthQueuingStrategyConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16804{
16805 auto& vm = JSC::getVM(&lexicalGlobalObject);
16806 auto throwScope = DECLARE_THROW_SCOPE(vm);
16807 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16808 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16809 if (!shouldAllowAccess)
16810 return jsUndefined();
16811 return JSByteLengthQueuingStrategy::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16812}
16813
16814JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ByteLengthQueuingStrategyConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16815{
16816 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ByteLengthQueuingStrategyConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16817}
16818
16819static inline JSValue jsDOMWindow_CountQueuingStrategyConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16820{
16821 auto& vm = JSC::getVM(&lexicalGlobalObject);
16822 auto throwScope = DECLARE_THROW_SCOPE(vm);
16823 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16824 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16825 if (!shouldAllowAccess)
16826 return jsUndefined();
16827 return JSCountQueuingStrategy::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16828}
16829
16830JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CountQueuingStrategyConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16831{
16832 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CountQueuingStrategyConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16833}
16834
16835static inline JSValue jsDOMWindow_ReadableByteStreamControllerConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16836{
16837 auto& vm = JSC::getVM(&lexicalGlobalObject);
16838 auto throwScope = DECLARE_THROW_SCOPE(vm);
16839 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16840 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16841 if (!shouldAllowAccess)
16842 return jsUndefined();
16843 return JSReadableByteStreamController::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16844}
16845
16846JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ReadableByteStreamControllerConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16847{
16848 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ReadableByteStreamControllerConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16849}
16850
16851static inline JSValue jsDOMWindow_ReadableStreamConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16852{
16853 auto& vm = JSC::getVM(&lexicalGlobalObject);
16854 auto throwScope = DECLARE_THROW_SCOPE(vm);
16855 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16856 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16857 if (!shouldAllowAccess)
16858 return jsUndefined();
16859 return JSReadableStream::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16860}
16861
16862JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ReadableStreamConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16863{
16864 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ReadableStreamConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16865}
16866
16867static inline JSValue jsDOMWindow_ReadableStreamBYOBReaderConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16868{
16869 auto& vm = JSC::getVM(&lexicalGlobalObject);
16870 auto throwScope = DECLARE_THROW_SCOPE(vm);
16871 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16872 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16873 if (!shouldAllowAccess)
16874 return jsUndefined();
16875 return JSReadableStreamBYOBReader::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16876}
16877
16878JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ReadableStreamBYOBReaderConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16879{
16880 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ReadableStreamBYOBReaderConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16881}
16882
16883static inline JSValue jsDOMWindow_ReadableStreamBYOBRequestConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16884{
16885 auto& vm = JSC::getVM(&lexicalGlobalObject);
16886 auto throwScope = DECLARE_THROW_SCOPE(vm);
16887 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16888 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16889 if (!shouldAllowAccess)
16890 return jsUndefined();
16891 return JSReadableStreamBYOBRequest::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16892}
16893
16894JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ReadableStreamBYOBRequestConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16895{
16896 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ReadableStreamBYOBRequestConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16897}
16898
16899static inline JSValue jsDOMWindow_ReadableStreamDefaultControllerConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16900{
16901 auto& vm = JSC::getVM(&lexicalGlobalObject);
16902 auto throwScope = DECLARE_THROW_SCOPE(vm);
16903 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16904 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16905 if (!shouldAllowAccess)
16906 return jsUndefined();
16907 return JSReadableStreamDefaultController::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16908}
16909
16910JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ReadableStreamDefaultControllerConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16911{
16912 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ReadableStreamDefaultControllerConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16913}
16914
16915static inline JSValue jsDOMWindow_ReadableStreamDefaultReaderConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16916{
16917 auto& vm = JSC::getVM(&lexicalGlobalObject);
16918 auto throwScope = DECLARE_THROW_SCOPE(vm);
16919 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16920 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16921 if (!shouldAllowAccess)
16922 return jsUndefined();
16923 return JSReadableStreamDefaultReader::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16924}
16925
16926JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ReadableStreamDefaultReaderConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16927{
16928 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ReadableStreamDefaultReaderConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16929}
16930
16931static inline JSValue jsDOMWindow_TransformStreamConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16932{
16933 auto& vm = JSC::getVM(&lexicalGlobalObject);
16934 auto throwScope = DECLARE_THROW_SCOPE(vm);
16935 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16936 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16937 if (!shouldAllowAccess)
16938 return jsUndefined();
16939 return JSTransformStream::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16940}
16941
16942JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_TransformStreamConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16943{
16944 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_TransformStreamConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16945}
16946
16947static inline JSValue jsDOMWindow_TransformStreamDefaultControllerConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16948{
16949 auto& vm = JSC::getVM(&lexicalGlobalObject);
16950 auto throwScope = DECLARE_THROW_SCOPE(vm);
16951 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16952 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16953 if (!shouldAllowAccess)
16954 return jsUndefined();
16955 return JSTransformStreamDefaultController::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16956}
16957
16958JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_TransformStreamDefaultControllerConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16959{
16960 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_TransformStreamDefaultControllerConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16961}
16962
16963static inline JSValue jsDOMWindow_WritableStreamConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16964{
16965 auto& vm = JSC::getVM(&lexicalGlobalObject);
16966 auto throwScope = DECLARE_THROW_SCOPE(vm);
16967 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16968 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16969 if (!shouldAllowAccess)
16970 return jsUndefined();
16971 return JSWritableStream::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16972}
16973
16974JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WritableStreamConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16975{
16976 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WritableStreamConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16977}
16978
16979static inline JSValue jsDOMWindow_WritableStreamDefaultControllerConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16980{
16981 auto& vm = JSC::getVM(&lexicalGlobalObject);
16982 auto throwScope = DECLARE_THROW_SCOPE(vm);
16983 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
16984 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
16985 if (!shouldAllowAccess)
16986 return jsUndefined();
16987 return JSWritableStreamDefaultController::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
16988}
16989
16990JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WritableStreamDefaultControllerConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
16991{
16992 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WritableStreamDefaultControllerConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
16993}
16994
16995static inline JSValue jsDOMWindow_WritableStreamDefaultWriterConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
16996{
16997 auto& vm = JSC::getVM(&lexicalGlobalObject);
16998 auto throwScope = DECLARE_THROW_SCOPE(vm);
16999 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17000 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17001 if (!shouldAllowAccess)
17002 return jsUndefined();
17003 return JSWritableStreamDefaultWriter::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17004}
17005
17006JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WritableStreamDefaultWriterConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17007{
17008 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WritableStreamDefaultWriterConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17009}
17010
17011#if ENABLE(WEB_AUDIO)
17012static inline JSValue jsDOMWindow_AnalyserNodeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17013{
17014 auto& vm = JSC::getVM(&lexicalGlobalObject);
17015 auto throwScope = DECLARE_THROW_SCOPE(vm);
17016 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17017 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17018 if (!shouldAllowAccess)
17019 return jsUndefined();
17020 return JSAnalyserNode::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17021}
17022
17023JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_AnalyserNodeConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17024{
17025 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_AnalyserNodeConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17026}
17027
17028#endif
17029
17030#if ENABLE(WEB_AUDIO)
17031static inline JSValue jsDOMWindow_AudioBufferConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17032{
17033 auto& vm = JSC::getVM(&lexicalGlobalObject);
17034 auto throwScope = DECLARE_THROW_SCOPE(vm);
17035 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17036 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17037 if (!shouldAllowAccess)
17038 return jsUndefined();
17039 return JSAudioBuffer::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17040}
17041
17042JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_AudioBufferConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17043{
17044 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_AudioBufferConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17045}
17046
17047#endif
17048
17049#if ENABLE(WEB_AUDIO)
17050static inline JSValue jsDOMWindow_AudioBufferSourceNodeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17051{
17052 auto& vm = JSC::getVM(&lexicalGlobalObject);
17053 auto throwScope = DECLARE_THROW_SCOPE(vm);
17054 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17055 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17056 if (!shouldAllowAccess)
17057 return jsUndefined();
17058 return JSAudioBufferSourceNode::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17059}
17060
17061JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_AudioBufferSourceNodeConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17062{
17063 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_AudioBufferSourceNodeConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17064}
17065
17066#endif
17067
17068#if ENABLE(WEB_AUDIO)
17069static inline JSValue jsDOMWindow_AudioContextConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17070{
17071 auto& vm = JSC::getVM(&lexicalGlobalObject);
17072 auto throwScope = DECLARE_THROW_SCOPE(vm);
17073 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17074 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17075 if (!shouldAllowAccess)
17076 return jsUndefined();
17077 return JSAudioContext::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17078}
17079
17080JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_AudioContextConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17081{
17082 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_AudioContextConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17083}
17084
17085#endif
17086
17087#if ENABLE(WEB_AUDIO)
17088static inline JSValue jsDOMWindow_AudioDestinationNodeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17089{
17090 auto& vm = JSC::getVM(&lexicalGlobalObject);
17091 auto throwScope = DECLARE_THROW_SCOPE(vm);
17092 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17093 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17094 if (!shouldAllowAccess)
17095 return jsUndefined();
17096 return JSAudioDestinationNode::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17097}
17098
17099JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_AudioDestinationNodeConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17100{
17101 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_AudioDestinationNodeConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17102}
17103
17104#endif
17105
17106#if ENABLE(WEB_AUDIO)
17107static inline JSValue jsDOMWindow_AudioListenerConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17108{
17109 auto& vm = JSC::getVM(&lexicalGlobalObject);
17110 auto throwScope = DECLARE_THROW_SCOPE(vm);
17111 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17112 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17113 if (!shouldAllowAccess)
17114 return jsUndefined();
17115 return JSAudioListener::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17116}
17117
17118JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_AudioListenerConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17119{
17120 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_AudioListenerConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17121}
17122
17123#endif
17124
17125#if ENABLE(WEB_AUDIO)
17126static inline JSValue jsDOMWindow_AudioNodeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17127{
17128 auto& vm = JSC::getVM(&lexicalGlobalObject);
17129 auto throwScope = DECLARE_THROW_SCOPE(vm);
17130 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17131 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17132 if (!shouldAllowAccess)
17133 return jsUndefined();
17134 return JSAudioNode::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17135}
17136
17137JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_AudioNodeConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17138{
17139 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_AudioNodeConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17140}
17141
17142#endif
17143
17144#if ENABLE(WEB_AUDIO)
17145static inline JSValue jsDOMWindow_AudioParamConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17146{
17147 auto& vm = JSC::getVM(&lexicalGlobalObject);
17148 auto throwScope = DECLARE_THROW_SCOPE(vm);
17149 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17150 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17151 if (!shouldAllowAccess)
17152 return jsUndefined();
17153 return JSAudioParam::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17154}
17155
17156JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_AudioParamConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17157{
17158 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_AudioParamConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17159}
17160
17161#endif
17162
17163#if ENABLE(WEB_AUDIO)
17164static inline JSValue jsDOMWindow_AudioParamMapConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17165{
17166 auto& vm = JSC::getVM(&lexicalGlobalObject);
17167 auto throwScope = DECLARE_THROW_SCOPE(vm);
17168 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17169 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17170 if (!shouldAllowAccess)
17171 return jsUndefined();
17172 return JSAudioParamMap::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17173}
17174
17175JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_AudioParamMapConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17176{
17177 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_AudioParamMapConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17178}
17179
17180#endif
17181
17182#if ENABLE(WEB_AUDIO)
17183static inline JSValue jsDOMWindow_AudioProcessingEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17184{
17185 auto& vm = JSC::getVM(&lexicalGlobalObject);
17186 auto throwScope = DECLARE_THROW_SCOPE(vm);
17187 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17188 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17189 if (!shouldAllowAccess)
17190 return jsUndefined();
17191 return JSAudioProcessingEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17192}
17193
17194JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_AudioProcessingEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17195{
17196 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_AudioProcessingEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17197}
17198
17199#endif
17200
17201#if ENABLE(WEB_AUDIO)
17202static inline JSValue jsDOMWindow_AudioScheduledSourceNodeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17203{
17204 auto& vm = JSC::getVM(&lexicalGlobalObject);
17205 auto throwScope = DECLARE_THROW_SCOPE(vm);
17206 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17207 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17208 if (!shouldAllowAccess)
17209 return jsUndefined();
17210 return JSAudioScheduledSourceNode::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17211}
17212
17213JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_AudioScheduledSourceNodeConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17214{
17215 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_AudioScheduledSourceNodeConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17216}
17217
17218#endif
17219
17220#if ENABLE(WEB_AUDIO)
17221static inline JSValue jsDOMWindow_AudioWorkletConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17222{
17223 auto& vm = JSC::getVM(&lexicalGlobalObject);
17224 auto throwScope = DECLARE_THROW_SCOPE(vm);
17225 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17226 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17227 if (!shouldAllowAccess)
17228 return jsUndefined();
17229 return JSAudioWorklet::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17230}
17231
17232JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_AudioWorkletConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17233{
17234 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_AudioWorkletConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17235}
17236
17237#endif
17238
17239#if ENABLE(WEB_AUDIO)
17240static inline JSValue jsDOMWindow_AudioWorkletNodeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17241{
17242 auto& vm = JSC::getVM(&lexicalGlobalObject);
17243 auto throwScope = DECLARE_THROW_SCOPE(vm);
17244 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17245 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17246 if (!shouldAllowAccess)
17247 return jsUndefined();
17248 return JSAudioWorkletNode::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17249}
17250
17251JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_AudioWorkletNodeConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17252{
17253 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_AudioWorkletNodeConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17254}
17255
17256#endif
17257
17258#if ENABLE(WEB_AUDIO)
17259static inline JSValue jsDOMWindow_BaseAudioContextConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17260{
17261 auto& vm = JSC::getVM(&lexicalGlobalObject);
17262 auto throwScope = DECLARE_THROW_SCOPE(vm);
17263 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17264 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17265 if (!shouldAllowAccess)
17266 return jsUndefined();
17267 return JSBaseAudioContext::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17268}
17269
17270JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_BaseAudioContextConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17271{
17272 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_BaseAudioContextConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17273}
17274
17275#endif
17276
17277#if ENABLE(WEB_AUDIO)
17278static inline JSValue jsDOMWindow_BiquadFilterNodeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17279{
17280 auto& vm = JSC::getVM(&lexicalGlobalObject);
17281 auto throwScope = DECLARE_THROW_SCOPE(vm);
17282 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17283 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17284 if (!shouldAllowAccess)
17285 return jsUndefined();
17286 return JSBiquadFilterNode::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17287}
17288
17289JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_BiquadFilterNodeConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17290{
17291 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_BiquadFilterNodeConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17292}
17293
17294#endif
17295
17296#if ENABLE(WEB_AUDIO)
17297static inline JSValue jsDOMWindow_ChannelMergerNodeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17298{
17299 auto& vm = JSC::getVM(&lexicalGlobalObject);
17300 auto throwScope = DECLARE_THROW_SCOPE(vm);
17301 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17302 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17303 if (!shouldAllowAccess)
17304 return jsUndefined();
17305 return JSChannelMergerNode::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17306}
17307
17308JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ChannelMergerNodeConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17309{
17310 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ChannelMergerNodeConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17311}
17312
17313#endif
17314
17315#if ENABLE(WEB_AUDIO)
17316static inline JSValue jsDOMWindow_ChannelSplitterNodeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17317{
17318 auto& vm = JSC::getVM(&lexicalGlobalObject);
17319 auto throwScope = DECLARE_THROW_SCOPE(vm);
17320 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17321 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17322 if (!shouldAllowAccess)
17323 return jsUndefined();
17324 return JSChannelSplitterNode::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17325}
17326
17327JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ChannelSplitterNodeConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17328{
17329 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ChannelSplitterNodeConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17330}
17331
17332#endif
17333
17334#if ENABLE(WEB_AUDIO)
17335static inline JSValue jsDOMWindow_ConstantSourceNodeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17336{
17337 auto& vm = JSC::getVM(&lexicalGlobalObject);
17338 auto throwScope = DECLARE_THROW_SCOPE(vm);
17339 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17340 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17341 if (!shouldAllowAccess)
17342 return jsUndefined();
17343 return JSConstantSourceNode::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17344}
17345
17346JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ConstantSourceNodeConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17347{
17348 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ConstantSourceNodeConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17349}
17350
17351#endif
17352
17353#if ENABLE(WEB_AUDIO)
17354static inline JSValue jsDOMWindow_ConvolverNodeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17355{
17356 auto& vm = JSC::getVM(&lexicalGlobalObject);
17357 auto throwScope = DECLARE_THROW_SCOPE(vm);
17358 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17359 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17360 if (!shouldAllowAccess)
17361 return jsUndefined();
17362 return JSConvolverNode::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17363}
17364
17365JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ConvolverNodeConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17366{
17367 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ConvolverNodeConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17368}
17369
17370#endif
17371
17372#if ENABLE(WEB_AUDIO)
17373static inline JSValue jsDOMWindow_DelayNodeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17374{
17375 auto& vm = JSC::getVM(&lexicalGlobalObject);
17376 auto throwScope = DECLARE_THROW_SCOPE(vm);
17377 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17378 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17379 if (!shouldAllowAccess)
17380 return jsUndefined();
17381 return JSDelayNode::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17382}
17383
17384JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_DelayNodeConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17385{
17386 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_DelayNodeConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17387}
17388
17389#endif
17390
17391#if ENABLE(WEB_AUDIO)
17392static inline JSValue jsDOMWindow_DynamicsCompressorNodeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17393{
17394 auto& vm = JSC::getVM(&lexicalGlobalObject);
17395 auto throwScope = DECLARE_THROW_SCOPE(vm);
17396 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17397 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17398 if (!shouldAllowAccess)
17399 return jsUndefined();
17400 return JSDynamicsCompressorNode::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17401}
17402
17403JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_DynamicsCompressorNodeConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17404{
17405 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_DynamicsCompressorNodeConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17406}
17407
17408#endif
17409
17410#if ENABLE(WEB_AUDIO)
17411static inline JSValue jsDOMWindow_GainNodeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17412{
17413 auto& vm = JSC::getVM(&lexicalGlobalObject);
17414 auto throwScope = DECLARE_THROW_SCOPE(vm);
17415 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17416 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17417 if (!shouldAllowAccess)
17418 return jsUndefined();
17419 return JSGainNode::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17420}
17421
17422JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GainNodeConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17423{
17424 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GainNodeConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17425}
17426
17427#endif
17428
17429#if ENABLE(WEB_AUDIO)
17430static inline JSValue jsDOMWindow_IIRFilterNodeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17431{
17432 auto& vm = JSC::getVM(&lexicalGlobalObject);
17433 auto throwScope = DECLARE_THROW_SCOPE(vm);
17434 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17435 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17436 if (!shouldAllowAccess)
17437 return jsUndefined();
17438 return JSIIRFilterNode::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17439}
17440
17441JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_IIRFilterNodeConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17442{
17443 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_IIRFilterNodeConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17444}
17445
17446#endif
17447
17448#if ENABLE(VIDEO) && ENABLE(WEB_AUDIO)
17449static inline JSValue jsDOMWindow_MediaElementAudioSourceNodeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17450{
17451 auto& vm = JSC::getVM(&lexicalGlobalObject);
17452 auto throwScope = DECLARE_THROW_SCOPE(vm);
17453 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17454 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17455 if (!shouldAllowAccess)
17456 return jsUndefined();
17457 return JSMediaElementAudioSourceNode::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17458}
17459
17460JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MediaElementAudioSourceNodeConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17461{
17462 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MediaElementAudioSourceNodeConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17463}
17464
17465#endif
17466
17467#if ENABLE(MEDIA_STREAM) && ENABLE(WEB_AUDIO)
17468static inline JSValue jsDOMWindow_MediaStreamAudioDestinationNodeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17469{
17470 auto& vm = JSC::getVM(&lexicalGlobalObject);
17471 auto throwScope = DECLARE_THROW_SCOPE(vm);
17472 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17473 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17474 if (!shouldAllowAccess)
17475 return jsUndefined();
17476 return JSMediaStreamAudioDestinationNode::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17477}
17478
17479JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MediaStreamAudioDestinationNodeConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17480{
17481 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MediaStreamAudioDestinationNodeConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17482}
17483
17484#endif
17485
17486#if ENABLE(MEDIA_STREAM) && ENABLE(WEB_AUDIO)
17487static inline JSValue jsDOMWindow_MediaStreamAudioSourceNodeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17488{
17489 auto& vm = JSC::getVM(&lexicalGlobalObject);
17490 auto throwScope = DECLARE_THROW_SCOPE(vm);
17491 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17492 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17493 if (!shouldAllowAccess)
17494 return jsUndefined();
17495 return JSMediaStreamAudioSourceNode::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17496}
17497
17498JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MediaStreamAudioSourceNodeConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17499{
17500 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MediaStreamAudioSourceNodeConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17501}
17502
17503#endif
17504
17505#if ENABLE(WEB_AUDIO)
17506static inline JSValue jsDOMWindow_OfflineAudioCompletionEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17507{
17508 auto& vm = JSC::getVM(&lexicalGlobalObject);
17509 auto throwScope = DECLARE_THROW_SCOPE(vm);
17510 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17511 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17512 if (!shouldAllowAccess)
17513 return jsUndefined();
17514 return JSOfflineAudioCompletionEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17515}
17516
17517JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_OfflineAudioCompletionEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17518{
17519 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_OfflineAudioCompletionEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17520}
17521
17522#endif
17523
17524#if ENABLE(WEB_AUDIO)
17525static inline JSValue jsDOMWindow_OfflineAudioContextConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17526{
17527 auto& vm = JSC::getVM(&lexicalGlobalObject);
17528 auto throwScope = DECLARE_THROW_SCOPE(vm);
17529 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17530 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17531 if (!shouldAllowAccess)
17532 return jsUndefined();
17533 return JSOfflineAudioContext::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17534}
17535
17536JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_OfflineAudioContextConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17537{
17538 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_OfflineAudioContextConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17539}
17540
17541#endif
17542
17543#if ENABLE(WEB_AUDIO)
17544static inline JSValue jsDOMWindow_OscillatorNodeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17545{
17546 auto& vm = JSC::getVM(&lexicalGlobalObject);
17547 auto throwScope = DECLARE_THROW_SCOPE(vm);
17548 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17549 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17550 if (!shouldAllowAccess)
17551 return jsUndefined();
17552 return JSOscillatorNode::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17553}
17554
17555JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_OscillatorNodeConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17556{
17557 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_OscillatorNodeConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17558}
17559
17560#endif
17561
17562#if ENABLE(WEB_AUDIO)
17563static inline JSValue jsDOMWindow_PannerNodeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17564{
17565 auto& vm = JSC::getVM(&lexicalGlobalObject);
17566 auto throwScope = DECLARE_THROW_SCOPE(vm);
17567 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17568 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17569 if (!shouldAllowAccess)
17570 return jsUndefined();
17571 return JSPannerNode::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17572}
17573
17574JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_PannerNodeConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17575{
17576 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_PannerNodeConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17577}
17578
17579#endif
17580
17581#if ENABLE(WEB_AUDIO)
17582static inline JSValue jsDOMWindow_PeriodicWaveConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17583{
17584 auto& vm = JSC::getVM(&lexicalGlobalObject);
17585 auto throwScope = DECLARE_THROW_SCOPE(vm);
17586 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17587 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17588 if (!shouldAllowAccess)
17589 return jsUndefined();
17590 return JSPeriodicWave::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17591}
17592
17593JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_PeriodicWaveConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17594{
17595 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_PeriodicWaveConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17596}
17597
17598#endif
17599
17600#if ENABLE(WEB_AUDIO)
17601static inline JSValue jsDOMWindow_ScriptProcessorNodeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17602{
17603 auto& vm = JSC::getVM(&lexicalGlobalObject);
17604 auto throwScope = DECLARE_THROW_SCOPE(vm);
17605 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17606 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17607 if (!shouldAllowAccess)
17608 return jsUndefined();
17609 return JSScriptProcessorNode::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17610}
17611
17612JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ScriptProcessorNodeConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17613{
17614 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ScriptProcessorNodeConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17615}
17616
17617#endif
17618
17619#if ENABLE(WEB_AUDIO)
17620static inline JSValue jsDOMWindow_StereoPannerNodeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17621{
17622 auto& vm = JSC::getVM(&lexicalGlobalObject);
17623 auto throwScope = DECLARE_THROW_SCOPE(vm);
17624 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17625 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17626 if (!shouldAllowAccess)
17627 return jsUndefined();
17628 return JSStereoPannerNode::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17629}
17630
17631JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_StereoPannerNodeConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17632{
17633 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_StereoPannerNodeConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17634}
17635
17636#endif
17637
17638#if ENABLE(WEB_AUDIO)
17639static inline JSValue jsDOMWindow_WaveShaperNodeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17640{
17641 auto& vm = JSC::getVM(&lexicalGlobalObject);
17642 auto throwScope = DECLARE_THROW_SCOPE(vm);
17643 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17644 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17645 if (!shouldAllowAccess)
17646 return jsUndefined();
17647 return JSWaveShaperNode::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17648}
17649
17650JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WaveShaperNodeConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17651{
17652 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WaveShaperNodeConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17653}
17654
17655#endif
17656
17657#if ENABLE(WEB_AUTHN)
17658static inline JSValue jsDOMWindow_AuthenticatorAssertionResponseConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17659{
17660 auto& vm = JSC::getVM(&lexicalGlobalObject);
17661 auto throwScope = DECLARE_THROW_SCOPE(vm);
17662 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17663 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17664 if (!shouldAllowAccess)
17665 return jsUndefined();
17666 return JSAuthenticatorAssertionResponse::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17667}
17668
17669JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_AuthenticatorAssertionResponseConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17670{
17671 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_AuthenticatorAssertionResponseConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17672}
17673
17674#endif
17675
17676#if ENABLE(WEB_AUTHN)
17677static inline JSValue jsDOMWindow_AuthenticatorAttestationResponseConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17678{
17679 auto& vm = JSC::getVM(&lexicalGlobalObject);
17680 auto throwScope = DECLARE_THROW_SCOPE(vm);
17681 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17682 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17683 if (!shouldAllowAccess)
17684 return jsUndefined();
17685 return JSAuthenticatorAttestationResponse::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17686}
17687
17688JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_AuthenticatorAttestationResponseConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17689{
17690 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_AuthenticatorAttestationResponseConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17691}
17692
17693#endif
17694
17695#if ENABLE(WEB_AUTHN)
17696static inline JSValue jsDOMWindow_AuthenticatorResponseConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17697{
17698 auto& vm = JSC::getVM(&lexicalGlobalObject);
17699 auto throwScope = DECLARE_THROW_SCOPE(vm);
17700 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17701 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17702 if (!shouldAllowAccess)
17703 return jsUndefined();
17704 return JSAuthenticatorResponse::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17705}
17706
17707JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_AuthenticatorResponseConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17708{
17709 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_AuthenticatorResponseConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17710}
17711
17712#endif
17713
17714#if ENABLE(WEB_AUTHN)
17715static inline JSValue jsDOMWindow_PublicKeyCredentialConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17716{
17717 auto& vm = JSC::getVM(&lexicalGlobalObject);
17718 auto throwScope = DECLARE_THROW_SCOPE(vm);
17719 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17720 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17721 if (!shouldAllowAccess)
17722 return jsUndefined();
17723 return JSPublicKeyCredential::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17724}
17725
17726JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_PublicKeyCredentialConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17727{
17728 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_PublicKeyCredentialConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17729}
17730
17731#endif
17732
17733static inline JSValue jsDOMWindow_DatabaseConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17734{
17735 auto& vm = JSC::getVM(&lexicalGlobalObject);
17736 auto throwScope = DECLARE_THROW_SCOPE(vm);
17737 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17738 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17739 if (!shouldAllowAccess)
17740 return jsUndefined();
17741 return JSDatabase::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17742}
17743
17744JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_DatabaseConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17745{
17746 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_DatabaseConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17747}
17748
17749static inline JSValue jsDOMWindow_SQLErrorConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17750{
17751 auto& vm = JSC::getVM(&lexicalGlobalObject);
17752 auto throwScope = DECLARE_THROW_SCOPE(vm);
17753 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17754 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17755 if (!shouldAllowAccess)
17756 return jsUndefined();
17757 return JSSQLError::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17758}
17759
17760JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SQLErrorConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17761{
17762 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SQLErrorConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17763}
17764
17765static inline JSValue jsDOMWindow_SQLResultSetConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17766{
17767 auto& vm = JSC::getVM(&lexicalGlobalObject);
17768 auto throwScope = DECLARE_THROW_SCOPE(vm);
17769 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17770 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17771 if (!shouldAllowAccess)
17772 return jsUndefined();
17773 return JSSQLResultSet::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17774}
17775
17776JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SQLResultSetConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17777{
17778 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SQLResultSetConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17779}
17780
17781static inline JSValue jsDOMWindow_SQLResultSetRowListConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17782{
17783 auto& vm = JSC::getVM(&lexicalGlobalObject);
17784 auto throwScope = DECLARE_THROW_SCOPE(vm);
17785 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17786 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17787 if (!shouldAllowAccess)
17788 return jsUndefined();
17789 return JSSQLResultSetRowList::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17790}
17791
17792JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SQLResultSetRowListConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17793{
17794 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SQLResultSetRowListConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17795}
17796
17797static inline JSValue jsDOMWindow_SQLTransactionConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17798{
17799 auto& vm = JSC::getVM(&lexicalGlobalObject);
17800 auto throwScope = DECLARE_THROW_SCOPE(vm);
17801 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17802 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17803 if (!shouldAllowAccess)
17804 return jsUndefined();
17805 return JSSQLTransaction::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17806}
17807
17808JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SQLTransactionConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17809{
17810 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SQLTransactionConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17811}
17812
17813#if ENABLE(WEBGPU)
17814static inline JSValue jsDOMWindow_GPUBufferUsageConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17815{
17816 auto& vm = JSC::getVM(&lexicalGlobalObject);
17817 auto throwScope = DECLARE_THROW_SCOPE(vm);
17818 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17819 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17820 if (!shouldAllowAccess)
17821 return jsUndefined();
17822 return JSGPUBufferUsage::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17823}
17824
17825JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GPUBufferUsageConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17826{
17827 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GPUBufferUsageConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17828}
17829
17830#endif
17831
17832#if ENABLE(WEBGPU)
17833static inline JSValue jsDOMWindow_GPUCanvasContextConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17834{
17835 auto& vm = JSC::getVM(&lexicalGlobalObject);
17836 auto throwScope = DECLARE_THROW_SCOPE(vm);
17837 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17838 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17839 if (!shouldAllowAccess)
17840 return jsUndefined();
17841 return JSGPUCanvasContext::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17842}
17843
17844JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GPUCanvasContextConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17845{
17846 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GPUCanvasContextConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17847}
17848
17849#endif
17850
17851#if ENABLE(WEBGPU)
17852static inline JSValue jsDOMWindow_GPUColorWriteConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17853{
17854 auto& vm = JSC::getVM(&lexicalGlobalObject);
17855 auto throwScope = DECLARE_THROW_SCOPE(vm);
17856 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17857 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17858 if (!shouldAllowAccess)
17859 return jsUndefined();
17860 return JSGPUColorWrite::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17861}
17862
17863JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GPUColorWriteConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17864{
17865 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GPUColorWriteConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17866}
17867
17868#endif
17869
17870#if ENABLE(WEBGPU)
17871static inline JSValue jsDOMWindow_GPUOutOfMemoryErrorConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17872{
17873 auto& vm = JSC::getVM(&lexicalGlobalObject);
17874 auto throwScope = DECLARE_THROW_SCOPE(vm);
17875 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17876 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17877 if (!shouldAllowAccess)
17878 return jsUndefined();
17879 return JSGPUOutOfMemoryError::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17880}
17881
17882JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GPUOutOfMemoryErrorConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17883{
17884 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GPUOutOfMemoryErrorConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17885}
17886
17887#endif
17888
17889#if ENABLE(WEBGPU)
17890static inline JSValue jsDOMWindow_GPUShaderStageConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17891{
17892 auto& vm = JSC::getVM(&lexicalGlobalObject);
17893 auto throwScope = DECLARE_THROW_SCOPE(vm);
17894 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17895 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17896 if (!shouldAllowAccess)
17897 return jsUndefined();
17898 return JSGPUShaderStage::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17899}
17900
17901JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GPUShaderStageConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17902{
17903 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GPUShaderStageConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17904}
17905
17906#endif
17907
17908#if ENABLE(WEBGPU)
17909static inline JSValue jsDOMWindow_GPUTextureUsageConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17910{
17911 auto& vm = JSC::getVM(&lexicalGlobalObject);
17912 auto throwScope = DECLARE_THROW_SCOPE(vm);
17913 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17914 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17915 if (!shouldAllowAccess)
17916 return jsUndefined();
17917 return JSGPUTextureUsage::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17918}
17919
17920JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GPUTextureUsageConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17921{
17922 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GPUTextureUsageConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17923}
17924
17925#endif
17926
17927#if ENABLE(WEBGPU)
17928static inline JSValue jsDOMWindow_GPUUncapturedErrorEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17929{
17930 auto& vm = JSC::getVM(&lexicalGlobalObject);
17931 auto throwScope = DECLARE_THROW_SCOPE(vm);
17932 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17933 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17934 if (!shouldAllowAccess)
17935 return jsUndefined();
17936 return JSGPUUncapturedErrorEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17937}
17938
17939JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GPUUncapturedErrorEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17940{
17941 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GPUUncapturedErrorEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17942}
17943
17944#endif
17945
17946#if ENABLE(WEBGPU)
17947static inline JSValue jsDOMWindow_GPUValidationErrorConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17948{
17949 auto& vm = JSC::getVM(&lexicalGlobalObject);
17950 auto throwScope = DECLARE_THROW_SCOPE(vm);
17951 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17952 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17953 if (!shouldAllowAccess)
17954 return jsUndefined();
17955 return JSGPUValidationError::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17956}
17957
17958JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GPUValidationErrorConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17959{
17960 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GPUValidationErrorConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17961}
17962
17963#endif
17964
17965#if ENABLE(WEBGPU)
17966static inline JSValue jsDOMWindow_GPUConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17967{
17968 auto& vm = JSC::getVM(&lexicalGlobalObject);
17969 auto throwScope = DECLARE_THROW_SCOPE(vm);
17970 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17971 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17972 if (!shouldAllowAccess)
17973 return jsUndefined();
17974 return JSWebGPU::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17975}
17976
17977JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GPUConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17978{
17979 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GPUConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17980}
17981
17982#endif
17983
17984#if ENABLE(WEBGPU)
17985static inline JSValue jsDOMWindow_GPUAdapterConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
17986{
17987 auto& vm = JSC::getVM(&lexicalGlobalObject);
17988 auto throwScope = DECLARE_THROW_SCOPE(vm);
17989 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
17990 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
17991 if (!shouldAllowAccess)
17992 return jsUndefined();
17993 return JSWebGPUAdapter::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
17994}
17995
17996JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GPUAdapterConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
17997{
17998 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GPUAdapterConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
17999}
18000
18001#endif
18002
18003#if ENABLE(WEBGPU)
18004static inline JSValue jsDOMWindow_GPUBindGroupConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18005{
18006 auto& vm = JSC::getVM(&lexicalGlobalObject);
18007 auto throwScope = DECLARE_THROW_SCOPE(vm);
18008 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18009 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18010 if (!shouldAllowAccess)
18011 return jsUndefined();
18012 return JSWebGPUBindGroup::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18013}
18014
18015JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GPUBindGroupConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18016{
18017 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GPUBindGroupConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18018}
18019
18020#endif
18021
18022#if ENABLE(WEBGPU)
18023static inline JSValue jsDOMWindow_GPUBindGroupLayoutConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18024{
18025 auto& vm = JSC::getVM(&lexicalGlobalObject);
18026 auto throwScope = DECLARE_THROW_SCOPE(vm);
18027 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18028 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18029 if (!shouldAllowAccess)
18030 return jsUndefined();
18031 return JSWebGPUBindGroupLayout::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18032}
18033
18034JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GPUBindGroupLayoutConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18035{
18036 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GPUBindGroupLayoutConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18037}
18038
18039#endif
18040
18041#if ENABLE(WEBGPU)
18042static inline JSValue jsDOMWindow_GPUBufferConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18043{
18044 auto& vm = JSC::getVM(&lexicalGlobalObject);
18045 auto throwScope = DECLARE_THROW_SCOPE(vm);
18046 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18047 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18048 if (!shouldAllowAccess)
18049 return jsUndefined();
18050 return JSWebGPUBuffer::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18051}
18052
18053JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GPUBufferConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18054{
18055 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GPUBufferConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18056}
18057
18058#endif
18059
18060#if ENABLE(WEBGPU)
18061static inline JSValue jsDOMWindow_GPUCommandBufferConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18062{
18063 auto& vm = JSC::getVM(&lexicalGlobalObject);
18064 auto throwScope = DECLARE_THROW_SCOPE(vm);
18065 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18066 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18067 if (!shouldAllowAccess)
18068 return jsUndefined();
18069 return JSWebGPUCommandBuffer::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18070}
18071
18072JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GPUCommandBufferConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18073{
18074 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GPUCommandBufferConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18075}
18076
18077#endif
18078
18079#if ENABLE(WEBGPU)
18080static inline JSValue jsDOMWindow_GPUCommandEncoderConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18081{
18082 auto& vm = JSC::getVM(&lexicalGlobalObject);
18083 auto throwScope = DECLARE_THROW_SCOPE(vm);
18084 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18085 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18086 if (!shouldAllowAccess)
18087 return jsUndefined();
18088 return JSWebGPUCommandEncoder::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18089}
18090
18091JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GPUCommandEncoderConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18092{
18093 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GPUCommandEncoderConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18094}
18095
18096#endif
18097
18098#if ENABLE(WEBGPU)
18099static inline JSValue jsDOMWindow_GPUComputePassEncoderConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18100{
18101 auto& vm = JSC::getVM(&lexicalGlobalObject);
18102 auto throwScope = DECLARE_THROW_SCOPE(vm);
18103 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18104 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18105 if (!shouldAllowAccess)
18106 return jsUndefined();
18107 return JSWebGPUComputePassEncoder::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18108}
18109
18110JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GPUComputePassEncoderConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18111{
18112 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GPUComputePassEncoderConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18113}
18114
18115#endif
18116
18117#if ENABLE(WEBGPU)
18118static inline JSValue jsDOMWindow_GPUComputePipelineConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18119{
18120 auto& vm = JSC::getVM(&lexicalGlobalObject);
18121 auto throwScope = DECLARE_THROW_SCOPE(vm);
18122 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18123 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18124 if (!shouldAllowAccess)
18125 return jsUndefined();
18126 return JSWebGPUComputePipeline::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18127}
18128
18129JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GPUComputePipelineConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18130{
18131 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GPUComputePipelineConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18132}
18133
18134#endif
18135
18136#if ENABLE(WEBGPU)
18137static inline JSValue jsDOMWindow_GPUDeviceConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18138{
18139 auto& vm = JSC::getVM(&lexicalGlobalObject);
18140 auto throwScope = DECLARE_THROW_SCOPE(vm);
18141 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18142 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18143 if (!shouldAllowAccess)
18144 return jsUndefined();
18145 return JSWebGPUDevice::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18146}
18147
18148JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GPUDeviceConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18149{
18150 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GPUDeviceConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18151}
18152
18153#endif
18154
18155#if ENABLE(WEBGPU)
18156static inline JSValue jsDOMWindow_GPUPipelineLayoutConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18157{
18158 auto& vm = JSC::getVM(&lexicalGlobalObject);
18159 auto throwScope = DECLARE_THROW_SCOPE(vm);
18160 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18161 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18162 if (!shouldAllowAccess)
18163 return jsUndefined();
18164 return JSWebGPUPipelineLayout::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18165}
18166
18167JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GPUPipelineLayoutConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18168{
18169 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GPUPipelineLayoutConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18170}
18171
18172#endif
18173
18174#if ENABLE(WEBGPU)
18175static inline JSValue jsDOMWindow_GPUProgrammablePassEncoderConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18176{
18177 auto& vm = JSC::getVM(&lexicalGlobalObject);
18178 auto throwScope = DECLARE_THROW_SCOPE(vm);
18179 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18180 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18181 if (!shouldAllowAccess)
18182 return jsUndefined();
18183 return JSWebGPUProgrammablePassEncoder::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18184}
18185
18186JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GPUProgrammablePassEncoderConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18187{
18188 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GPUProgrammablePassEncoderConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18189}
18190
18191#endif
18192
18193#if ENABLE(WEBGPU)
18194static inline JSValue jsDOMWindow_GPUQueueConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18195{
18196 auto& vm = JSC::getVM(&lexicalGlobalObject);
18197 auto throwScope = DECLARE_THROW_SCOPE(vm);
18198 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18199 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18200 if (!shouldAllowAccess)
18201 return jsUndefined();
18202 return JSWebGPUQueue::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18203}
18204
18205JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GPUQueueConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18206{
18207 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GPUQueueConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18208}
18209
18210#endif
18211
18212#if ENABLE(WEBGPU)
18213static inline JSValue jsDOMWindow_GPURenderPassEncoderConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18214{
18215 auto& vm = JSC::getVM(&lexicalGlobalObject);
18216 auto throwScope = DECLARE_THROW_SCOPE(vm);
18217 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18218 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18219 if (!shouldAllowAccess)
18220 return jsUndefined();
18221 return JSWebGPURenderPassEncoder::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18222}
18223
18224JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GPURenderPassEncoderConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18225{
18226 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GPURenderPassEncoderConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18227}
18228
18229#endif
18230
18231#if ENABLE(WEBGPU)
18232static inline JSValue jsDOMWindow_GPURenderPipelineConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18233{
18234 auto& vm = JSC::getVM(&lexicalGlobalObject);
18235 auto throwScope = DECLARE_THROW_SCOPE(vm);
18236 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18237 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18238 if (!shouldAllowAccess)
18239 return jsUndefined();
18240 return JSWebGPURenderPipeline::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18241}
18242
18243JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GPURenderPipelineConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18244{
18245 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GPURenderPipelineConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18246}
18247
18248#endif
18249
18250#if ENABLE(WEBGPU)
18251static inline JSValue jsDOMWindow_GPUSamplerConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18252{
18253 auto& vm = JSC::getVM(&lexicalGlobalObject);
18254 auto throwScope = DECLARE_THROW_SCOPE(vm);
18255 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18256 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18257 if (!shouldAllowAccess)
18258 return jsUndefined();
18259 return JSWebGPUSampler::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18260}
18261
18262JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GPUSamplerConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18263{
18264 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GPUSamplerConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18265}
18266
18267#endif
18268
18269#if ENABLE(WEBGPU)
18270static inline JSValue jsDOMWindow_GPUShaderModuleConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18271{
18272 auto& vm = JSC::getVM(&lexicalGlobalObject);
18273 auto throwScope = DECLARE_THROW_SCOPE(vm);
18274 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18275 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18276 if (!shouldAllowAccess)
18277 return jsUndefined();
18278 return JSWebGPUShaderModule::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18279}
18280
18281JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GPUShaderModuleConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18282{
18283 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GPUShaderModuleConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18284}
18285
18286#endif
18287
18288#if ENABLE(WEBGPU)
18289static inline JSValue jsDOMWindow_GPUSwapChainConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18290{
18291 auto& vm = JSC::getVM(&lexicalGlobalObject);
18292 auto throwScope = DECLARE_THROW_SCOPE(vm);
18293 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18294 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18295 if (!shouldAllowAccess)
18296 return jsUndefined();
18297 return JSWebGPUSwapChain::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18298}
18299
18300JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GPUSwapChainConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18301{
18302 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GPUSwapChainConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18303}
18304
18305#endif
18306
18307#if ENABLE(WEBGPU)
18308static inline JSValue jsDOMWindow_GPUTextureConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18309{
18310 auto& vm = JSC::getVM(&lexicalGlobalObject);
18311 auto throwScope = DECLARE_THROW_SCOPE(vm);
18312 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18313 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18314 if (!shouldAllowAccess)
18315 return jsUndefined();
18316 return JSWebGPUTexture::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18317}
18318
18319JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GPUTextureConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18320{
18321 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GPUTextureConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18322}
18323
18324#endif
18325
18326#if ENABLE(WEBGPU)
18327static inline JSValue jsDOMWindow_GPUTextureViewConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18328{
18329 auto& vm = JSC::getVM(&lexicalGlobalObject);
18330 auto throwScope = DECLARE_THROW_SCOPE(vm);
18331 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18332 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18333 if (!shouldAllowAccess)
18334 return jsUndefined();
18335 return JSWebGPUTextureView::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18336}
18337
18338JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_GPUTextureViewConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18339{
18340 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_GPUTextureViewConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18341}
18342
18343#endif
18344
18345static inline JSValue jsDOMWindow_CloseEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18346{
18347 auto& vm = JSC::getVM(&lexicalGlobalObject);
18348 auto throwScope = DECLARE_THROW_SCOPE(vm);
18349 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18350 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18351 if (!shouldAllowAccess)
18352 return jsUndefined();
18353 return JSCloseEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18354}
18355
18356JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CloseEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18357{
18358 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CloseEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18359}
18360
18361static inline JSValue jsDOMWindow_WebSocketConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18362{
18363 auto& vm = JSC::getVM(&lexicalGlobalObject);
18364 auto throwScope = DECLARE_THROW_SCOPE(vm);
18365 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18366 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18367 if (!shouldAllowAccess)
18368 return jsUndefined();
18369 return JSWebSocket::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18370}
18371
18372JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WebSocketConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18373{
18374 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WebSocketConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18375}
18376
18377#if ENABLE(WEBXR)
18378static inline JSValue jsDOMWindow_XRBoundedReferenceSpaceConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18379{
18380 auto& vm = JSC::getVM(&lexicalGlobalObject);
18381 auto throwScope = DECLARE_THROW_SCOPE(vm);
18382 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18383 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18384 if (!shouldAllowAccess)
18385 return jsUndefined();
18386 return JSWebXRBoundedReferenceSpace::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18387}
18388
18389JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_XRBoundedReferenceSpaceConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18390{
18391 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_XRBoundedReferenceSpaceConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18392}
18393
18394#endif
18395
18396#if ENABLE(WEBXR)
18397static inline JSValue jsDOMWindow_XRFrameConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18398{
18399 auto& vm = JSC::getVM(&lexicalGlobalObject);
18400 auto throwScope = DECLARE_THROW_SCOPE(vm);
18401 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18402 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18403 if (!shouldAllowAccess)
18404 return jsUndefined();
18405 return JSWebXRFrame::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18406}
18407
18408JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_XRFrameConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18409{
18410 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_XRFrameConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18411}
18412
18413#endif
18414
18415#if ENABLE(WEBXR)
18416static inline JSValue jsDOMWindow_XRInputSourceConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18417{
18418 auto& vm = JSC::getVM(&lexicalGlobalObject);
18419 auto throwScope = DECLARE_THROW_SCOPE(vm);
18420 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18421 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18422 if (!shouldAllowAccess)
18423 return jsUndefined();
18424 return JSWebXRInputSource::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18425}
18426
18427JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_XRInputSourceConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18428{
18429 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_XRInputSourceConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18430}
18431
18432#endif
18433
18434#if ENABLE(WEBXR)
18435static inline JSValue jsDOMWindow_XRInputSourceArrayConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18436{
18437 auto& vm = JSC::getVM(&lexicalGlobalObject);
18438 auto throwScope = DECLARE_THROW_SCOPE(vm);
18439 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18440 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18441 if (!shouldAllowAccess)
18442 return jsUndefined();
18443 return JSWebXRInputSourceArray::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18444}
18445
18446JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_XRInputSourceArrayConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18447{
18448 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_XRInputSourceArrayConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18449}
18450
18451#endif
18452
18453#if ENABLE(WEBXR)
18454static inline JSValue jsDOMWindow_XRLayerConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18455{
18456 auto& vm = JSC::getVM(&lexicalGlobalObject);
18457 auto throwScope = DECLARE_THROW_SCOPE(vm);
18458 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18459 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18460 if (!shouldAllowAccess)
18461 return jsUndefined();
18462 return JSWebXRLayer::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18463}
18464
18465JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_XRLayerConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18466{
18467 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_XRLayerConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18468}
18469
18470#endif
18471
18472#if ENABLE(WEBXR)
18473static inline JSValue jsDOMWindow_XRPoseConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18474{
18475 auto& vm = JSC::getVM(&lexicalGlobalObject);
18476 auto throwScope = DECLARE_THROW_SCOPE(vm);
18477 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18478 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18479 if (!shouldAllowAccess)
18480 return jsUndefined();
18481 return JSWebXRPose::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18482}
18483
18484JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_XRPoseConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18485{
18486 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_XRPoseConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18487}
18488
18489#endif
18490
18491#if ENABLE(WEBXR)
18492static inline JSValue jsDOMWindow_XRReferenceSpaceConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18493{
18494 auto& vm = JSC::getVM(&lexicalGlobalObject);
18495 auto throwScope = DECLARE_THROW_SCOPE(vm);
18496 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18497 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18498 if (!shouldAllowAccess)
18499 return jsUndefined();
18500 return JSWebXRReferenceSpace::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18501}
18502
18503JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_XRReferenceSpaceConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18504{
18505 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_XRReferenceSpaceConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18506}
18507
18508#endif
18509
18510#if ENABLE(WEBXR)
18511static inline JSValue jsDOMWindow_XRRenderStateConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18512{
18513 auto& vm = JSC::getVM(&lexicalGlobalObject);
18514 auto throwScope = DECLARE_THROW_SCOPE(vm);
18515 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18516 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18517 if (!shouldAllowAccess)
18518 return jsUndefined();
18519 return JSWebXRRenderState::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18520}
18521
18522JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_XRRenderStateConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18523{
18524 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_XRRenderStateConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18525}
18526
18527#endif
18528
18529#if ENABLE(WEBXR)
18530static inline JSValue jsDOMWindow_XRRigidTransformConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18531{
18532 auto& vm = JSC::getVM(&lexicalGlobalObject);
18533 auto throwScope = DECLARE_THROW_SCOPE(vm);
18534 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18535 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18536 if (!shouldAllowAccess)
18537 return jsUndefined();
18538 return JSWebXRRigidTransform::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18539}
18540
18541JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_XRRigidTransformConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18542{
18543 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_XRRigidTransformConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18544}
18545
18546#endif
18547
18548#if ENABLE(WEBXR)
18549static inline JSValue jsDOMWindow_XRSessionConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18550{
18551 auto& vm = JSC::getVM(&lexicalGlobalObject);
18552 auto throwScope = DECLARE_THROW_SCOPE(vm);
18553 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18554 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18555 if (!shouldAllowAccess)
18556 return jsUndefined();
18557 return JSWebXRSession::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18558}
18559
18560JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_XRSessionConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18561{
18562 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_XRSessionConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18563}
18564
18565#endif
18566
18567#if ENABLE(WEBXR)
18568static inline JSValue jsDOMWindow_XRSpaceConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18569{
18570 auto& vm = JSC::getVM(&lexicalGlobalObject);
18571 auto throwScope = DECLARE_THROW_SCOPE(vm);
18572 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18573 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18574 if (!shouldAllowAccess)
18575 return jsUndefined();
18576 return JSWebXRSpace::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18577}
18578
18579JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_XRSpaceConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18580{
18581 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_XRSpaceConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18582}
18583
18584#endif
18585
18586#if ENABLE(WEBXR)
18587static inline JSValue jsDOMWindow_XRSystemConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18588{
18589 auto& vm = JSC::getVM(&lexicalGlobalObject);
18590 auto throwScope = DECLARE_THROW_SCOPE(vm);
18591 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18592 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18593 if (!shouldAllowAccess)
18594 return jsUndefined();
18595 return JSWebXRSystem::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18596}
18597
18598JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_XRSystemConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18599{
18600 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_XRSystemConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18601}
18602
18603#endif
18604
18605#if ENABLE(WEBXR)
18606static inline JSValue jsDOMWindow_XRViewConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18607{
18608 auto& vm = JSC::getVM(&lexicalGlobalObject);
18609 auto throwScope = DECLARE_THROW_SCOPE(vm);
18610 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18611 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18612 if (!shouldAllowAccess)
18613 return jsUndefined();
18614 return JSWebXRView::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18615}
18616
18617JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_XRViewConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18618{
18619 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_XRViewConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18620}
18621
18622#endif
18623
18624#if ENABLE(WEBXR)
18625static inline JSValue jsDOMWindow_XRViewerPoseConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18626{
18627 auto& vm = JSC::getVM(&lexicalGlobalObject);
18628 auto throwScope = DECLARE_THROW_SCOPE(vm);
18629 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18630 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18631 if (!shouldAllowAccess)
18632 return jsUndefined();
18633 return JSWebXRViewerPose::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18634}
18635
18636JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_XRViewerPoseConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18637{
18638 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_XRViewerPoseConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18639}
18640
18641#endif
18642
18643#if ENABLE(WEBXR)
18644static inline JSValue jsDOMWindow_XRViewportConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18645{
18646 auto& vm = JSC::getVM(&lexicalGlobalObject);
18647 auto throwScope = DECLARE_THROW_SCOPE(vm);
18648 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18649 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18650 if (!shouldAllowAccess)
18651 return jsUndefined();
18652 return JSWebXRViewport::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18653}
18654
18655JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_XRViewportConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18656{
18657 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_XRViewportConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18658}
18659
18660#endif
18661
18662#if ENABLE(WEBXR)
18663static inline JSValue jsDOMWindow_XRWebGLLayerConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18664{
18665 auto& vm = JSC::getVM(&lexicalGlobalObject);
18666 auto throwScope = DECLARE_THROW_SCOPE(vm);
18667 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18668 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18669 if (!shouldAllowAccess)
18670 return jsUndefined();
18671 return JSWebXRWebGLLayer::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18672}
18673
18674JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_XRWebGLLayerConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18675{
18676 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_XRWebGLLayerConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18677}
18678
18679#endif
18680
18681#if ENABLE(WEBXR)
18682static inline JSValue jsDOMWindow_XRInputSourceEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18683{
18684 auto& vm = JSC::getVM(&lexicalGlobalObject);
18685 auto throwScope = DECLARE_THROW_SCOPE(vm);
18686 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18687 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18688 if (!shouldAllowAccess)
18689 return jsUndefined();
18690 return JSXRInputSourceEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18691}
18692
18693JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_XRInputSourceEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18694{
18695 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_XRInputSourceEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18696}
18697
18698#endif
18699
18700#if ENABLE(WEBXR)
18701static inline JSValue jsDOMWindow_XRInputSourcesChangeEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18702{
18703 auto& vm = JSC::getVM(&lexicalGlobalObject);
18704 auto throwScope = DECLARE_THROW_SCOPE(vm);
18705 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18706 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18707 if (!shouldAllowAccess)
18708 return jsUndefined();
18709 return JSXRInputSourcesChangeEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18710}
18711
18712JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_XRInputSourcesChangeEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18713{
18714 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_XRInputSourcesChangeEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18715}
18716
18717#endif
18718
18719#if ENABLE(WEBXR)
18720static inline JSValue jsDOMWindow_XRReferenceSpaceEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18721{
18722 auto& vm = JSC::getVM(&lexicalGlobalObject);
18723 auto throwScope = DECLARE_THROW_SCOPE(vm);
18724 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18725 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18726 if (!shouldAllowAccess)
18727 return jsUndefined();
18728 return JSXRReferenceSpaceEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18729}
18730
18731JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_XRReferenceSpaceEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18732{
18733 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_XRReferenceSpaceEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18734}
18735
18736#endif
18737
18738#if ENABLE(WEBXR)
18739static inline JSValue jsDOMWindow_XRSessionEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18740{
18741 auto& vm = JSC::getVM(&lexicalGlobalObject);
18742 auto throwScope = DECLARE_THROW_SCOPE(vm);
18743 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18744 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18745 if (!shouldAllowAccess)
18746 return jsUndefined();
18747 return JSXRSessionEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18748}
18749
18750JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_XRSessionEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18751{
18752 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_XRSessionEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18753}
18754
18755#endif
18756
18757static inline JSValue jsDOMWindow_AnimationEffectConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18758{
18759 auto& vm = JSC::getVM(&lexicalGlobalObject);
18760 auto throwScope = DECLARE_THROW_SCOPE(vm);
18761 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18762 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18763 if (!shouldAllowAccess)
18764 return jsUndefined();
18765 return JSAnimationEffect::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18766}
18767
18768JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_AnimationEffectConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18769{
18770 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_AnimationEffectConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18771}
18772
18773static inline JSValue jsDOMWindow_AnimationPlaybackEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18774{
18775 auto& vm = JSC::getVM(&lexicalGlobalObject);
18776 auto throwScope = DECLARE_THROW_SCOPE(vm);
18777 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18778 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18779 if (!shouldAllowAccess)
18780 return jsUndefined();
18781 return JSAnimationPlaybackEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18782}
18783
18784JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_AnimationPlaybackEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18785{
18786 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_AnimationPlaybackEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18787}
18788
18789static inline JSValue jsDOMWindow_AnimationTimelineConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18790{
18791 auto& vm = JSC::getVM(&lexicalGlobalObject);
18792 auto throwScope = DECLARE_THROW_SCOPE(vm);
18793 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18794 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18795 if (!shouldAllowAccess)
18796 return jsUndefined();
18797 return JSAnimationTimeline::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18798}
18799
18800JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_AnimationTimelineConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18801{
18802 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_AnimationTimelineConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18803}
18804
18805static inline JSValue jsDOMWindow_CSSAnimationConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18806{
18807 auto& vm = JSC::getVM(&lexicalGlobalObject);
18808 auto throwScope = DECLARE_THROW_SCOPE(vm);
18809 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18810 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18811 if (!shouldAllowAccess)
18812 return jsUndefined();
18813 return JSCSSAnimation::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18814}
18815
18816JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CSSAnimationConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18817{
18818 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CSSAnimationConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18819}
18820
18821static inline JSValue jsDOMWindow_CSSTransitionConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18822{
18823 auto& vm = JSC::getVM(&lexicalGlobalObject);
18824 auto throwScope = DECLARE_THROW_SCOPE(vm);
18825 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18826 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18827 if (!shouldAllowAccess)
18828 return jsUndefined();
18829 return JSCSSTransition::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18830}
18831
18832JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CSSTransitionConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18833{
18834 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CSSTransitionConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18835}
18836
18837static inline JSValue jsDOMWindow_DocumentTimelineConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18838{
18839 auto& vm = JSC::getVM(&lexicalGlobalObject);
18840 auto throwScope = DECLARE_THROW_SCOPE(vm);
18841 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18842 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18843 if (!shouldAllowAccess)
18844 return jsUndefined();
18845 return JSDocumentTimeline::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18846}
18847
18848JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_DocumentTimelineConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18849{
18850 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_DocumentTimelineConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18851}
18852
18853static inline JSValue jsDOMWindow_KeyframeEffectConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18854{
18855 auto& vm = JSC::getVM(&lexicalGlobalObject);
18856 auto throwScope = DECLARE_THROW_SCOPE(vm);
18857 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18858 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18859 if (!shouldAllowAccess)
18860 return jsUndefined();
18861 return JSKeyframeEffect::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18862}
18863
18864JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_KeyframeEffectConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18865{
18866 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_KeyframeEffectConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18867}
18868
18869static inline JSValue jsDOMWindow_AnimationConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18870{
18871 auto& vm = JSC::getVM(&lexicalGlobalObject);
18872 auto throwScope = DECLARE_THROW_SCOPE(vm);
18873 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18874 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18875 if (!shouldAllowAccess)
18876 return jsUndefined();
18877 return JSWebAnimation::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18878}
18879
18880JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_AnimationConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18881{
18882 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_AnimationConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18883}
18884
18885#if ENABLE(WEB_CRYPTO)
18886static inline JSValue jsDOMWindow_CryptoKeyConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18887{
18888 auto& vm = JSC::getVM(&lexicalGlobalObject);
18889 auto throwScope = DECLARE_THROW_SCOPE(vm);
18890 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18891 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18892 if (!shouldAllowAccess)
18893 return jsUndefined();
18894 return JSCryptoKey::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18895}
18896
18897JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CryptoKeyConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18898{
18899 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CryptoKeyConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18900}
18901
18902#endif
18903
18904#if ENABLE(WEB_CRYPTO)
18905static inline JSValue jsDOMWindow_SubtleCryptoConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18906{
18907 auto& vm = JSC::getVM(&lexicalGlobalObject);
18908 auto throwScope = DECLARE_THROW_SCOPE(vm);
18909 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18910 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18911 if (!shouldAllowAccess)
18912 return jsUndefined();
18913 return JSSubtleCrypto::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18914}
18915
18916JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SubtleCryptoConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18917{
18918 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SubtleCryptoConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18919}
18920
18921#endif
18922
18923static inline JSValue jsDOMWindow_CSSConditionRuleConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18924{
18925 auto& vm = JSC::getVM(&lexicalGlobalObject);
18926 auto throwScope = DECLARE_THROW_SCOPE(vm);
18927 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18928 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18929 if (!shouldAllowAccess)
18930 return jsUndefined();
18931 return JSCSSConditionRule::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18932}
18933
18934JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CSSConditionRuleConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18935{
18936 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CSSConditionRuleConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18937}
18938
18939static inline JSValue jsDOMWindow_CSSCounterStyleRuleConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18940{
18941 auto& vm = JSC::getVM(&lexicalGlobalObject);
18942 auto throwScope = DECLARE_THROW_SCOPE(vm);
18943 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18944 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18945 if (!shouldAllowAccess)
18946 return jsUndefined();
18947 return JSCSSCounterStyleRule::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18948}
18949
18950JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CSSCounterStyleRuleConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18951{
18952 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CSSCounterStyleRuleConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18953}
18954
18955static inline JSValue jsDOMWindow_CSSFontFaceRuleConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18956{
18957 auto& vm = JSC::getVM(&lexicalGlobalObject);
18958 auto throwScope = DECLARE_THROW_SCOPE(vm);
18959 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18960 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18961 if (!shouldAllowAccess)
18962 return jsUndefined();
18963 return JSCSSFontFaceRule::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18964}
18965
18966JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CSSFontFaceRuleConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18967{
18968 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CSSFontFaceRuleConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18969}
18970
18971static inline JSValue jsDOMWindow_CSSGroupingRuleConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18972{
18973 auto& vm = JSC::getVM(&lexicalGlobalObject);
18974 auto throwScope = DECLARE_THROW_SCOPE(vm);
18975 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18976 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18977 if (!shouldAllowAccess)
18978 return jsUndefined();
18979 return JSCSSGroupingRule::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18980}
18981
18982JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CSSGroupingRuleConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18983{
18984 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CSSGroupingRuleConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
18985}
18986
18987static inline JSValue jsDOMWindow_CSSImportRuleConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
18988{
18989 auto& vm = JSC::getVM(&lexicalGlobalObject);
18990 auto throwScope = DECLARE_THROW_SCOPE(vm);
18991 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
18992 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
18993 if (!shouldAllowAccess)
18994 return jsUndefined();
18995 return JSCSSImportRule::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
18996}
18997
18998JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CSSImportRuleConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
18999{
19000 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CSSImportRuleConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19001}
19002
19003static inline JSValue jsDOMWindow_CSSKeyframeRuleConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19004{
19005 auto& vm = JSC::getVM(&lexicalGlobalObject);
19006 auto throwScope = DECLARE_THROW_SCOPE(vm);
19007 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19008 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19009 if (!shouldAllowAccess)
19010 return jsUndefined();
19011 return JSCSSKeyframeRule::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19012}
19013
19014JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CSSKeyframeRuleConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19015{
19016 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CSSKeyframeRuleConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19017}
19018
19019static inline JSValue jsDOMWindow_CSSKeyframesRuleConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19020{
19021 auto& vm = JSC::getVM(&lexicalGlobalObject);
19022 auto throwScope = DECLARE_THROW_SCOPE(vm);
19023 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19024 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19025 if (!shouldAllowAccess)
19026 return jsUndefined();
19027 return JSCSSKeyframesRule::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19028}
19029
19030JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CSSKeyframesRuleConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19031{
19032 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CSSKeyframesRuleConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19033}
19034
19035static inline JSValue jsDOMWindow_CSSMediaRuleConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19036{
19037 auto& vm = JSC::getVM(&lexicalGlobalObject);
19038 auto throwScope = DECLARE_THROW_SCOPE(vm);
19039 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19040 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19041 if (!shouldAllowAccess)
19042 return jsUndefined();
19043 return JSCSSMediaRule::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19044}
19045
19046JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CSSMediaRuleConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19047{
19048 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CSSMediaRuleConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19049}
19050
19051static inline JSValue jsDOMWindow_CSSNamespaceRuleConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19052{
19053 auto& vm = JSC::getVM(&lexicalGlobalObject);
19054 auto throwScope = DECLARE_THROW_SCOPE(vm);
19055 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19056 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19057 if (!shouldAllowAccess)
19058 return jsUndefined();
19059 return JSCSSNamespaceRule::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19060}
19061
19062JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CSSNamespaceRuleConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19063{
19064 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CSSNamespaceRuleConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19065}
19066
19067static inline JSValue jsDOMWindow_CSSPageRuleConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19068{
19069 auto& vm = JSC::getVM(&lexicalGlobalObject);
19070 auto throwScope = DECLARE_THROW_SCOPE(vm);
19071 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19072 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19073 if (!shouldAllowAccess)
19074 return jsUndefined();
19075 return JSCSSPageRule::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19076}
19077
19078JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CSSPageRuleConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19079{
19080 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CSSPageRuleConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19081}
19082
19083static inline JSValue jsDOMWindow_CSSRuleConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19084{
19085 auto& vm = JSC::getVM(&lexicalGlobalObject);
19086 auto throwScope = DECLARE_THROW_SCOPE(vm);
19087 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19088 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19089 if (!shouldAllowAccess)
19090 return jsUndefined();
19091 return JSCSSRule::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19092}
19093
19094JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CSSRuleConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19095{
19096 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CSSRuleConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19097}
19098
19099static inline JSValue jsDOMWindow_CSSRuleListConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19100{
19101 auto& vm = JSC::getVM(&lexicalGlobalObject);
19102 auto throwScope = DECLARE_THROW_SCOPE(vm);
19103 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19104 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19105 if (!shouldAllowAccess)
19106 return jsUndefined();
19107 return JSCSSRuleList::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19108}
19109
19110JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CSSRuleListConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19111{
19112 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CSSRuleListConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19113}
19114
19115static inline JSValue jsDOMWindow_CSSStyleDeclarationConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19116{
19117 auto& vm = JSC::getVM(&lexicalGlobalObject);
19118 auto throwScope = DECLARE_THROW_SCOPE(vm);
19119 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19120 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19121 if (!shouldAllowAccess)
19122 return jsUndefined();
19123 return JSCSSStyleDeclaration::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19124}
19125
19126JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CSSStyleDeclarationConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19127{
19128 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CSSStyleDeclarationConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19129}
19130
19131static inline JSValue jsDOMWindow_CSSStyleRuleConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19132{
19133 auto& vm = JSC::getVM(&lexicalGlobalObject);
19134 auto throwScope = DECLARE_THROW_SCOPE(vm);
19135 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19136 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19137 if (!shouldAllowAccess)
19138 return jsUndefined();
19139 return JSCSSStyleRule::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19140}
19141
19142JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CSSStyleRuleConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19143{
19144 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CSSStyleRuleConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19145}
19146
19147static inline JSValue jsDOMWindow_CSSStyleSheetConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19148{
19149 auto& vm = JSC::getVM(&lexicalGlobalObject);
19150 auto throwScope = DECLARE_THROW_SCOPE(vm);
19151 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19152 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19153 if (!shouldAllowAccess)
19154 return jsUndefined();
19155 return JSCSSStyleSheet::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19156}
19157
19158JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CSSStyleSheetConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19159{
19160 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CSSStyleSheetConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19161}
19162
19163static inline JSValue jsDOMWindow_CSSSupportsRuleConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19164{
19165 auto& vm = JSC::getVM(&lexicalGlobalObject);
19166 auto throwScope = DECLARE_THROW_SCOPE(vm);
19167 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19168 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19169 if (!shouldAllowAccess)
19170 return jsUndefined();
19171 return JSCSSSupportsRule::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19172}
19173
19174JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CSSSupportsRuleConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19175{
19176 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CSSSupportsRuleConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19177}
19178
19179static inline JSValue jsDOMWindow_CSSConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19180{
19181 auto& vm = JSC::getVM(&lexicalGlobalObject);
19182 auto throwScope = DECLARE_THROW_SCOPE(vm);
19183 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19184 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19185 if (!shouldAllowAccess)
19186 return jsUndefined();
19187 return JSDOMCSSNamespace::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19188}
19189
19190JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CSSConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19191{
19192 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CSSConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19193}
19194
19195static inline JSValue jsDOMWindow_DOMMatrixConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19196{
19197 auto& vm = JSC::getVM(&lexicalGlobalObject);
19198 auto throwScope = DECLARE_THROW_SCOPE(vm);
19199 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19200 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19201 if (!shouldAllowAccess)
19202 return jsUndefined();
19203 return JSDOMMatrix::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19204}
19205
19206JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_DOMMatrixConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19207{
19208 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_DOMMatrixConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19209}
19210
19211static inline JSValue jsDOMWindow_WebKitCSSMatrixConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19212{
19213 auto& vm = JSC::getVM(&lexicalGlobalObject);
19214 auto throwScope = DECLARE_THROW_SCOPE(vm);
19215 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19216 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19217 if (!shouldAllowAccess)
19218 return jsUndefined();
19219 return JSDOMMatrix::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19220}
19221
19222JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WebKitCSSMatrixConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19223{
19224 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WebKitCSSMatrixConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19225}
19226
19227static inline JSValue jsDOMWindow_DOMMatrixReadOnlyConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19228{
19229 auto& vm = JSC::getVM(&lexicalGlobalObject);
19230 auto throwScope = DECLARE_THROW_SCOPE(vm);
19231 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19232 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19233 if (!shouldAllowAccess)
19234 return jsUndefined();
19235 return JSDOMMatrixReadOnly::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19236}
19237
19238JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_DOMMatrixReadOnlyConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19239{
19240 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_DOMMatrixReadOnlyConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19241}
19242
19243static inline JSValue jsDOMWindow_CounterConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19244{
19245 auto& vm = JSC::getVM(&lexicalGlobalObject);
19246 auto throwScope = DECLARE_THROW_SCOPE(vm);
19247 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19248 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19249 if (!shouldAllowAccess)
19250 return jsUndefined();
19251 return JSDeprecatedCSSOMCounter::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19252}
19253
19254JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CounterConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19255{
19256 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CounterConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19257}
19258
19259static inline JSValue jsDOMWindow_CSSPrimitiveValueConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19260{
19261 auto& vm = JSC::getVM(&lexicalGlobalObject);
19262 auto throwScope = DECLARE_THROW_SCOPE(vm);
19263 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19264 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19265 if (!shouldAllowAccess)
19266 return jsUndefined();
19267 return JSDeprecatedCSSOMPrimitiveValue::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19268}
19269
19270JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CSSPrimitiveValueConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19271{
19272 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CSSPrimitiveValueConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19273}
19274
19275static inline JSValue jsDOMWindow_RGBColorConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19276{
19277 auto& vm = JSC::getVM(&lexicalGlobalObject);
19278 auto throwScope = DECLARE_THROW_SCOPE(vm);
19279 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19280 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19281 if (!shouldAllowAccess)
19282 return jsUndefined();
19283 return JSDeprecatedCSSOMRGBColor::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19284}
19285
19286JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_RGBColorConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19287{
19288 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_RGBColorConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19289}
19290
19291static inline JSValue jsDOMWindow_RectConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19292{
19293 auto& vm = JSC::getVM(&lexicalGlobalObject);
19294 auto throwScope = DECLARE_THROW_SCOPE(vm);
19295 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19296 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19297 if (!shouldAllowAccess)
19298 return jsUndefined();
19299 return JSDeprecatedCSSOMRect::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19300}
19301
19302JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_RectConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19303{
19304 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_RectConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19305}
19306
19307static inline JSValue jsDOMWindow_CSSValueConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19308{
19309 auto& vm = JSC::getVM(&lexicalGlobalObject);
19310 auto throwScope = DECLARE_THROW_SCOPE(vm);
19311 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19312 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19313 if (!shouldAllowAccess)
19314 return jsUndefined();
19315 return JSDeprecatedCSSOMValue::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19316}
19317
19318JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CSSValueConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19319{
19320 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CSSValueConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19321}
19322
19323static inline JSValue jsDOMWindow_CSSValueListConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19324{
19325 auto& vm = JSC::getVM(&lexicalGlobalObject);
19326 auto throwScope = DECLARE_THROW_SCOPE(vm);
19327 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19328 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19329 if (!shouldAllowAccess)
19330 return jsUndefined();
19331 return JSDeprecatedCSSOMValueList::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19332}
19333
19334JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CSSValueListConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19335{
19336 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CSSValueListConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19337}
19338
19339static inline JSValue jsDOMWindow_FontFaceConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19340{
19341 auto& vm = JSC::getVM(&lexicalGlobalObject);
19342 auto throwScope = DECLARE_THROW_SCOPE(vm);
19343 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19344 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19345 if (!shouldAllowAccess)
19346 return jsUndefined();
19347 return JSFontFace::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19348}
19349
19350JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_FontFaceConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19351{
19352 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_FontFaceConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19353}
19354
19355static inline JSValue jsDOMWindow_FontFaceSetConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19356{
19357 auto& vm = JSC::getVM(&lexicalGlobalObject);
19358 auto throwScope = DECLARE_THROW_SCOPE(vm);
19359 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19360 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19361 if (!shouldAllowAccess)
19362 return jsUndefined();
19363 return JSFontFaceSet::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19364}
19365
19366JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_FontFaceSetConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19367{
19368 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_FontFaceSetConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19369}
19370
19371static inline JSValue jsDOMWindow_MediaListConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19372{
19373 auto& vm = JSC::getVM(&lexicalGlobalObject);
19374 auto throwScope = DECLARE_THROW_SCOPE(vm);
19375 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19376 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19377 if (!shouldAllowAccess)
19378 return jsUndefined();
19379 return JSMediaList::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19380}
19381
19382JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MediaListConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19383{
19384 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MediaListConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19385}
19386
19387static inline JSValue jsDOMWindow_MediaQueryListConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19388{
19389 auto& vm = JSC::getVM(&lexicalGlobalObject);
19390 auto throwScope = DECLARE_THROW_SCOPE(vm);
19391 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19392 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19393 if (!shouldAllowAccess)
19394 return jsUndefined();
19395 return JSMediaQueryList::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19396}
19397
19398JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MediaQueryListConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19399{
19400 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MediaQueryListConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19401}
19402
19403static inline JSValue jsDOMWindow_MediaQueryListEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19404{
19405 auto& vm = JSC::getVM(&lexicalGlobalObject);
19406 auto throwScope = DECLARE_THROW_SCOPE(vm);
19407 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19408 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19409 if (!shouldAllowAccess)
19410 return jsUndefined();
19411 return JSMediaQueryListEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19412}
19413
19414JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MediaQueryListEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19415{
19416 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MediaQueryListEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19417}
19418
19419static inline JSValue jsDOMWindow_StyleSheetConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19420{
19421 auto& vm = JSC::getVM(&lexicalGlobalObject);
19422 auto throwScope = DECLARE_THROW_SCOPE(vm);
19423 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19424 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19425 if (!shouldAllowAccess)
19426 return jsUndefined();
19427 return JSStyleSheet::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19428}
19429
19430JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_StyleSheetConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19431{
19432 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_StyleSheetConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19433}
19434
19435static inline JSValue jsDOMWindow_StyleSheetListConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19436{
19437 auto& vm = JSC::getVM(&lexicalGlobalObject);
19438 auto throwScope = DECLARE_THROW_SCOPE(vm);
19439 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19440 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19441 if (!shouldAllowAccess)
19442 return jsUndefined();
19443 return JSStyleSheetList::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19444}
19445
19446JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_StyleSheetListConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19447{
19448 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_StyleSheetListConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19449}
19450
19451#if ENABLE(CSS_TYPED_OM)
19452static inline JSValue jsDOMWindow_StylePropertyMapConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19453{
19454 auto& vm = JSC::getVM(&lexicalGlobalObject);
19455 auto throwScope = DECLARE_THROW_SCOPE(vm);
19456 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19457 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19458 if (!shouldAllowAccess)
19459 return jsUndefined();
19460 return JSStylePropertyMap::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19461}
19462
19463JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_StylePropertyMapConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19464{
19465 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_StylePropertyMapConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19466}
19467
19468#endif
19469
19470#if ENABLE(CSS_TYPED_OM)
19471static inline JSValue jsDOMWindow_StylePropertyMapReadOnlyConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19472{
19473 auto& vm = JSC::getVM(&lexicalGlobalObject);
19474 auto throwScope = DECLARE_THROW_SCOPE(vm);
19475 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19476 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19477 if (!shouldAllowAccess)
19478 return jsUndefined();
19479 return JSStylePropertyMapReadOnly::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19480}
19481
19482JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_StylePropertyMapReadOnlyConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19483{
19484 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_StylePropertyMapReadOnlyConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19485}
19486
19487#endif
19488
19489#if ENABLE(CSS_TYPED_OM)
19490static inline JSValue jsDOMWindow_CSSImageValueConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19491{
19492 auto& vm = JSC::getVM(&lexicalGlobalObject);
19493 auto throwScope = DECLARE_THROW_SCOPE(vm);
19494 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19495 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19496 if (!shouldAllowAccess)
19497 return jsUndefined();
19498 return JSTypedOMCSSImageValue::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19499}
19500
19501JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CSSImageValueConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19502{
19503 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CSSImageValueConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19504}
19505
19506#endif
19507
19508#if ENABLE(CSS_TYPED_OM)
19509static inline JSValue jsDOMWindow_CSSNumericValueConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19510{
19511 auto& vm = JSC::getVM(&lexicalGlobalObject);
19512 auto throwScope = DECLARE_THROW_SCOPE(vm);
19513 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19514 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19515 if (!shouldAllowAccess)
19516 return jsUndefined();
19517 return JSTypedOMCSSNumericValue::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19518}
19519
19520JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CSSNumericValueConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19521{
19522 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CSSNumericValueConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19523}
19524
19525#endif
19526
19527#if ENABLE(CSS_TYPED_OM)
19528static inline JSValue jsDOMWindow_CSSStyleValueConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19529{
19530 auto& vm = JSC::getVM(&lexicalGlobalObject);
19531 auto throwScope = DECLARE_THROW_SCOPE(vm);
19532 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19533 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19534 if (!shouldAllowAccess)
19535 return jsUndefined();
19536 return JSTypedOMCSSStyleValue::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19537}
19538
19539JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CSSStyleValueConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19540{
19541 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CSSStyleValueConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19542}
19543
19544#endif
19545
19546#if ENABLE(CSS_TYPED_OM)
19547static inline JSValue jsDOMWindow_CSSUnitValueConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19548{
19549 auto& vm = JSC::getVM(&lexicalGlobalObject);
19550 auto throwScope = DECLARE_THROW_SCOPE(vm);
19551 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19552 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19553 if (!shouldAllowAccess)
19554 return jsUndefined();
19555 return JSTypedOMCSSUnitValue::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19556}
19557
19558JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CSSUnitValueConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19559{
19560 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CSSUnitValueConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19561}
19562
19563#endif
19564
19565#if ENABLE(CSS_TYPED_OM)
19566static inline JSValue jsDOMWindow_CSSUnparsedValueConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19567{
19568 auto& vm = JSC::getVM(&lexicalGlobalObject);
19569 auto throwScope = DECLARE_THROW_SCOPE(vm);
19570 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19571 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19572 if (!shouldAllowAccess)
19573 return jsUndefined();
19574 return JSTypedOMCSSUnparsedValue::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19575}
19576
19577JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CSSUnparsedValueConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19578{
19579 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CSSUnparsedValueConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19580}
19581
19582#endif
19583
19584static inline JSValue jsDOMWindow_AbortControllerConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19585{
19586 auto& vm = JSC::getVM(&lexicalGlobalObject);
19587 auto throwScope = DECLARE_THROW_SCOPE(vm);
19588 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19589 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19590 if (!shouldAllowAccess)
19591 return jsUndefined();
19592 return JSAbortController::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19593}
19594
19595JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_AbortControllerConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19596{
19597 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_AbortControllerConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19598}
19599
19600static inline JSValue jsDOMWindow_AbortSignalConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19601{
19602 auto& vm = JSC::getVM(&lexicalGlobalObject);
19603 auto throwScope = DECLARE_THROW_SCOPE(vm);
19604 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19605 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19606 if (!shouldAllowAccess)
19607 return jsUndefined();
19608 return JSAbortSignal::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19609}
19610
19611JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_AbortSignalConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19612{
19613 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_AbortSignalConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19614}
19615
19616static inline JSValue jsDOMWindow_AbstractRangeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19617{
19618 auto& vm = JSC::getVM(&lexicalGlobalObject);
19619 auto throwScope = DECLARE_THROW_SCOPE(vm);
19620 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19621 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19622 if (!shouldAllowAccess)
19623 return jsUndefined();
19624 return JSAbstractRange::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19625}
19626
19627JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_AbstractRangeConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19628{
19629 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_AbstractRangeConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19630}
19631
19632static inline JSValue jsDOMWindow_AnimationEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19633{
19634 auto& vm = JSC::getVM(&lexicalGlobalObject);
19635 auto throwScope = DECLARE_THROW_SCOPE(vm);
19636 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19637 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19638 if (!shouldAllowAccess)
19639 return jsUndefined();
19640 return JSAnimationEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19641}
19642
19643JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_AnimationEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19644{
19645 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_AnimationEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19646}
19647
19648static inline JSValue jsDOMWindow_AttrConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19649{
19650 auto& vm = JSC::getVM(&lexicalGlobalObject);
19651 auto throwScope = DECLARE_THROW_SCOPE(vm);
19652 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19653 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19654 if (!shouldAllowAccess)
19655 return jsUndefined();
19656 return JSAttr::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19657}
19658
19659JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_AttrConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19660{
19661 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_AttrConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19662}
19663
19664static inline JSValue jsDOMWindow_BeforeLoadEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19665{
19666 auto& vm = JSC::getVM(&lexicalGlobalObject);
19667 auto throwScope = DECLARE_THROW_SCOPE(vm);
19668 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19669 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19670 if (!shouldAllowAccess)
19671 return jsUndefined();
19672 return JSBeforeLoadEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19673}
19674
19675JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_BeforeLoadEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19676{
19677 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_BeforeLoadEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19678}
19679
19680static inline JSValue jsDOMWindow_BeforeUnloadEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19681{
19682 auto& vm = JSC::getVM(&lexicalGlobalObject);
19683 auto throwScope = DECLARE_THROW_SCOPE(vm);
19684 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19685 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19686 if (!shouldAllowAccess)
19687 return jsUndefined();
19688 return JSBeforeUnloadEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19689}
19690
19691JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_BeforeUnloadEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19692{
19693 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_BeforeUnloadEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19694}
19695
19696static inline JSValue jsDOMWindow_CDATASectionConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19697{
19698 auto& vm = JSC::getVM(&lexicalGlobalObject);
19699 auto throwScope = DECLARE_THROW_SCOPE(vm);
19700 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19701 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19702 if (!shouldAllowAccess)
19703 return jsUndefined();
19704 return JSCDATASection::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19705}
19706
19707JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CDATASectionConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19708{
19709 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CDATASectionConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19710}
19711
19712static inline JSValue jsDOMWindow_CharacterDataConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19713{
19714 auto& vm = JSC::getVM(&lexicalGlobalObject);
19715 auto throwScope = DECLARE_THROW_SCOPE(vm);
19716 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19717 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19718 if (!shouldAllowAccess)
19719 return jsUndefined();
19720 return JSCharacterData::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19721}
19722
19723JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CharacterDataConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19724{
19725 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CharacterDataConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19726}
19727
19728static inline JSValue jsDOMWindow_ClipboardEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19729{
19730 auto& vm = JSC::getVM(&lexicalGlobalObject);
19731 auto throwScope = DECLARE_THROW_SCOPE(vm);
19732 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19733 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19734 if (!shouldAllowAccess)
19735 return jsUndefined();
19736 return JSClipboardEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19737}
19738
19739JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ClipboardEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19740{
19741 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ClipboardEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19742}
19743
19744static inline JSValue jsDOMWindow_CommentConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19745{
19746 auto& vm = JSC::getVM(&lexicalGlobalObject);
19747 auto throwScope = DECLARE_THROW_SCOPE(vm);
19748 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19749 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19750 if (!shouldAllowAccess)
19751 return jsUndefined();
19752 return JSComment::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19753}
19754
19755JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CommentConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19756{
19757 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CommentConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19758}
19759
19760static inline JSValue jsDOMWindow_CompositionEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19761{
19762 auto& vm = JSC::getVM(&lexicalGlobalObject);
19763 auto throwScope = DECLARE_THROW_SCOPE(vm);
19764 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19765 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19766 if (!shouldAllowAccess)
19767 return jsUndefined();
19768 return JSCompositionEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19769}
19770
19771JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CompositionEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19772{
19773 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CompositionEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19774}
19775
19776static inline JSValue jsDOMWindow_CustomElementRegistryConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19777{
19778 auto& vm = JSC::getVM(&lexicalGlobalObject);
19779 auto throwScope = DECLARE_THROW_SCOPE(vm);
19780 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19781 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19782 if (!shouldAllowAccess)
19783 return jsUndefined();
19784 return JSCustomElementRegistry::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19785}
19786
19787JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CustomElementRegistryConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19788{
19789 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CustomElementRegistryConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19790}
19791
19792static inline JSValue jsDOMWindow_CustomEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19793{
19794 auto& vm = JSC::getVM(&lexicalGlobalObject);
19795 auto throwScope = DECLARE_THROW_SCOPE(vm);
19796 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19797 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19798 if (!shouldAllowAccess)
19799 return jsUndefined();
19800 return JSCustomEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19801}
19802
19803JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CustomEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19804{
19805 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CustomEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19806}
19807
19808static inline JSValue jsDOMWindow_DOMExceptionConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19809{
19810 auto& vm = JSC::getVM(&lexicalGlobalObject);
19811 auto throwScope = DECLARE_THROW_SCOPE(vm);
19812 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19813 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19814 if (!shouldAllowAccess)
19815 return jsUndefined();
19816 return JSDOMException::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19817}
19818
19819JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_DOMExceptionConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19820{
19821 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_DOMExceptionConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19822}
19823
19824static inline JSValue jsDOMWindow_DOMImplementationConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19825{
19826 auto& vm = JSC::getVM(&lexicalGlobalObject);
19827 auto throwScope = DECLARE_THROW_SCOPE(vm);
19828 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19829 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19830 if (!shouldAllowAccess)
19831 return jsUndefined();
19832 return JSDOMImplementation::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19833}
19834
19835JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_DOMImplementationConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19836{
19837 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_DOMImplementationConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19838}
19839
19840static inline JSValue jsDOMWindow_DOMPointConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19841{
19842 auto& vm = JSC::getVM(&lexicalGlobalObject);
19843 auto throwScope = DECLARE_THROW_SCOPE(vm);
19844 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19845 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19846 if (!shouldAllowAccess)
19847 return jsUndefined();
19848 return JSDOMPoint::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19849}
19850
19851JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_DOMPointConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19852{
19853 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_DOMPointConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19854}
19855
19856static inline JSValue jsDOMWindow_DOMPointReadOnlyConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19857{
19858 auto& vm = JSC::getVM(&lexicalGlobalObject);
19859 auto throwScope = DECLARE_THROW_SCOPE(vm);
19860 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19861 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19862 if (!shouldAllowAccess)
19863 return jsUndefined();
19864 return JSDOMPointReadOnly::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19865}
19866
19867JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_DOMPointReadOnlyConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19868{
19869 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_DOMPointReadOnlyConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19870}
19871
19872static inline JSValue jsDOMWindow_DOMQuadConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19873{
19874 auto& vm = JSC::getVM(&lexicalGlobalObject);
19875 auto throwScope = DECLARE_THROW_SCOPE(vm);
19876 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19877 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19878 if (!shouldAllowAccess)
19879 return jsUndefined();
19880 return JSDOMQuad::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19881}
19882
19883JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_DOMQuadConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19884{
19885 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_DOMQuadConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19886}
19887
19888static inline JSValue jsDOMWindow_DOMRectConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19889{
19890 auto& vm = JSC::getVM(&lexicalGlobalObject);
19891 auto throwScope = DECLARE_THROW_SCOPE(vm);
19892 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19893 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19894 if (!shouldAllowAccess)
19895 return jsUndefined();
19896 return JSDOMRect::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19897}
19898
19899JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_DOMRectConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19900{
19901 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_DOMRectConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19902}
19903
19904static inline JSValue jsDOMWindow_DOMRectListConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19905{
19906 auto& vm = JSC::getVM(&lexicalGlobalObject);
19907 auto throwScope = DECLARE_THROW_SCOPE(vm);
19908 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19909 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19910 if (!shouldAllowAccess)
19911 return jsUndefined();
19912 return JSDOMRectList::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19913}
19914
19915JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_DOMRectListConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19916{
19917 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_DOMRectListConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19918}
19919
19920static inline JSValue jsDOMWindow_DOMRectReadOnlyConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19921{
19922 auto& vm = JSC::getVM(&lexicalGlobalObject);
19923 auto throwScope = DECLARE_THROW_SCOPE(vm);
19924 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19925 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19926 if (!shouldAllowAccess)
19927 return jsUndefined();
19928 return JSDOMRectReadOnly::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19929}
19930
19931JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_DOMRectReadOnlyConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19932{
19933 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_DOMRectReadOnlyConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19934}
19935
19936static inline JSValue jsDOMWindow_DOMStringListConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19937{
19938 auto& vm = JSC::getVM(&lexicalGlobalObject);
19939 auto throwScope = DECLARE_THROW_SCOPE(vm);
19940 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19941 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19942 if (!shouldAllowAccess)
19943 return jsUndefined();
19944 return JSDOMStringList::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19945}
19946
19947JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_DOMStringListConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19948{
19949 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_DOMStringListConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19950}
19951
19952static inline JSValue jsDOMWindow_DOMStringMapConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19953{
19954 auto& vm = JSC::getVM(&lexicalGlobalObject);
19955 auto throwScope = DECLARE_THROW_SCOPE(vm);
19956 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19957 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19958 if (!shouldAllowAccess)
19959 return jsUndefined();
19960 return JSDOMStringMap::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19961}
19962
19963JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_DOMStringMapConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19964{
19965 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_DOMStringMapConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19966}
19967
19968static inline JSValue jsDOMWindow_DataTransferConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19969{
19970 auto& vm = JSC::getVM(&lexicalGlobalObject);
19971 auto throwScope = DECLARE_THROW_SCOPE(vm);
19972 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19973 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19974 if (!shouldAllowAccess)
19975 return jsUndefined();
19976 return JSDataTransfer::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19977}
19978
19979JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_DataTransferConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19980{
19981 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_DataTransferConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19982}
19983
19984static inline JSValue jsDOMWindow_DataTransferItemConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
19985{
19986 auto& vm = JSC::getVM(&lexicalGlobalObject);
19987 auto throwScope = DECLARE_THROW_SCOPE(vm);
19988 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
19989 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
19990 if (!shouldAllowAccess)
19991 return jsUndefined();
19992 return JSDataTransferItem::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
19993}
19994
19995JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_DataTransferItemConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
19996{
19997 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_DataTransferItemConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
19998}
19999
20000static inline JSValue jsDOMWindow_DataTransferItemListConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20001{
20002 auto& vm = JSC::getVM(&lexicalGlobalObject);
20003 auto throwScope = DECLARE_THROW_SCOPE(vm);
20004 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20005 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20006 if (!shouldAllowAccess)
20007 return jsUndefined();
20008 return JSDataTransferItemList::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20009}
20010
20011JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_DataTransferItemListConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20012{
20013 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_DataTransferItemListConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20014}
20015
20016#if ENABLE(DEVICE_ORIENTATION)
20017static inline JSValue jsDOMWindow_DeviceMotionEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20018{
20019 auto& vm = JSC::getVM(&lexicalGlobalObject);
20020 auto throwScope = DECLARE_THROW_SCOPE(vm);
20021 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20022 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20023 if (!shouldAllowAccess)
20024 return jsUndefined();
20025 return JSDeviceMotionEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20026}
20027
20028JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_DeviceMotionEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20029{
20030 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_DeviceMotionEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20031}
20032
20033#endif
20034
20035#if ENABLE(DEVICE_ORIENTATION)
20036static inline JSValue jsDOMWindow_DeviceOrientationEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20037{
20038 auto& vm = JSC::getVM(&lexicalGlobalObject);
20039 auto throwScope = DECLARE_THROW_SCOPE(vm);
20040 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20041 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20042 if (!shouldAllowAccess)
20043 return jsUndefined();
20044 return JSDeviceOrientationEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20045}
20046
20047JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_DeviceOrientationEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20048{
20049 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_DeviceOrientationEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20050}
20051
20052#endif
20053
20054static inline JSValue jsDOMWindow_DocumentConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20055{
20056 auto& vm = JSC::getVM(&lexicalGlobalObject);
20057 auto throwScope = DECLARE_THROW_SCOPE(vm);
20058 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20059 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20060 if (!shouldAllowAccess)
20061 return jsUndefined();
20062 return JSDocument::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20063}
20064
20065JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_DocumentConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20066{
20067 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_DocumentConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20068}
20069
20070static inline JSValue jsDOMWindow_DocumentFragmentConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20071{
20072 auto& vm = JSC::getVM(&lexicalGlobalObject);
20073 auto throwScope = DECLARE_THROW_SCOPE(vm);
20074 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20075 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20076 if (!shouldAllowAccess)
20077 return jsUndefined();
20078 return JSDocumentFragment::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20079}
20080
20081JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_DocumentFragmentConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20082{
20083 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_DocumentFragmentConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20084}
20085
20086static inline JSValue jsDOMWindow_DocumentTypeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20087{
20088 auto& vm = JSC::getVM(&lexicalGlobalObject);
20089 auto throwScope = DECLARE_THROW_SCOPE(vm);
20090 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20091 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20092 if (!shouldAllowAccess)
20093 return jsUndefined();
20094 return JSDocumentType::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20095}
20096
20097JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_DocumentTypeConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20098{
20099 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_DocumentTypeConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20100}
20101
20102static inline JSValue jsDOMWindow_DragEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20103{
20104 auto& vm = JSC::getVM(&lexicalGlobalObject);
20105 auto throwScope = DECLARE_THROW_SCOPE(vm);
20106 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20107 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20108 if (!shouldAllowAccess)
20109 return jsUndefined();
20110 return JSDragEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20111}
20112
20113JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_DragEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20114{
20115 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_DragEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20116}
20117
20118static inline JSValue jsDOMWindow_ElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20119{
20120 auto& vm = JSC::getVM(&lexicalGlobalObject);
20121 auto throwScope = DECLARE_THROW_SCOPE(vm);
20122 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20123 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20124 if (!shouldAllowAccess)
20125 return jsUndefined();
20126 return JSElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20127}
20128
20129JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20130{
20131 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20132}
20133
20134static inline JSValue jsDOMWindow_ErrorEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20135{
20136 auto& vm = JSC::getVM(&lexicalGlobalObject);
20137 auto throwScope = DECLARE_THROW_SCOPE(vm);
20138 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20139 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20140 if (!shouldAllowAccess)
20141 return jsUndefined();
20142 return JSErrorEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20143}
20144
20145JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ErrorEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20146{
20147 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ErrorEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20148}
20149
20150static inline JSValue jsDOMWindow_EventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20151{
20152 auto& vm = JSC::getVM(&lexicalGlobalObject);
20153 auto throwScope = DECLARE_THROW_SCOPE(vm);
20154 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20155 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20156 if (!shouldAllowAccess)
20157 return jsUndefined();
20158 return JSEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20159}
20160
20161JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_EventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20162{
20163 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_EventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20164}
20165
20166static inline JSValue jsDOMWindow_EventTargetConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20167{
20168 auto& vm = JSC::getVM(&lexicalGlobalObject);
20169 auto throwScope = DECLARE_THROW_SCOPE(vm);
20170 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20171 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20172 if (!shouldAllowAccess)
20173 return jsUndefined();
20174 return JSEventTarget::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20175}
20176
20177JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_EventTargetConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20178{
20179 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_EventTargetConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20180}
20181
20182static inline JSValue jsDOMWindow_FocusEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20183{
20184 auto& vm = JSC::getVM(&lexicalGlobalObject);
20185 auto throwScope = DECLARE_THROW_SCOPE(vm);
20186 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20187 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20188 if (!shouldAllowAccess)
20189 return jsUndefined();
20190 return JSFocusEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20191}
20192
20193JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_FocusEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20194{
20195 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_FocusEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20196}
20197
20198static inline JSValue jsDOMWindow_HashChangeEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20199{
20200 auto& vm = JSC::getVM(&lexicalGlobalObject);
20201 auto throwScope = DECLARE_THROW_SCOPE(vm);
20202 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20203 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20204 if (!shouldAllowAccess)
20205 return jsUndefined();
20206 return JSHashChangeEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20207}
20208
20209JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HashChangeEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20210{
20211 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HashChangeEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20212}
20213
20214static inline JSValue jsDOMWindow_IdleDeadlineConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20215{
20216 auto& vm = JSC::getVM(&lexicalGlobalObject);
20217 auto throwScope = DECLARE_THROW_SCOPE(vm);
20218 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20219 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20220 if (!shouldAllowAccess)
20221 return jsUndefined();
20222 return JSIdleDeadline::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20223}
20224
20225JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_IdleDeadlineConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20226{
20227 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_IdleDeadlineConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20228}
20229
20230static inline JSValue jsDOMWindow_InputEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20231{
20232 auto& vm = JSC::getVM(&lexicalGlobalObject);
20233 auto throwScope = DECLARE_THROW_SCOPE(vm);
20234 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20235 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20236 if (!shouldAllowAccess)
20237 return jsUndefined();
20238 return JSInputEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20239}
20240
20241JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_InputEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20242{
20243 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_InputEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20244}
20245
20246static inline JSValue jsDOMWindow_KeyboardEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20247{
20248 auto& vm = JSC::getVM(&lexicalGlobalObject);
20249 auto throwScope = DECLARE_THROW_SCOPE(vm);
20250 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20251 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20252 if (!shouldAllowAccess)
20253 return jsUndefined();
20254 return JSKeyboardEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20255}
20256
20257JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_KeyboardEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20258{
20259 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_KeyboardEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20260}
20261
20262#if ENABLE(CHANNEL_MESSAGING)
20263static inline JSValue jsDOMWindow_MessageChannelConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20264{
20265 auto& vm = JSC::getVM(&lexicalGlobalObject);
20266 auto throwScope = DECLARE_THROW_SCOPE(vm);
20267 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20268 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20269 if (!shouldAllowAccess)
20270 return jsUndefined();
20271 return JSMessageChannel::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20272}
20273
20274JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MessageChannelConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20275{
20276 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MessageChannelConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20277}
20278
20279#endif
20280
20281static inline JSValue jsDOMWindow_MessageEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20282{
20283 auto& vm = JSC::getVM(&lexicalGlobalObject);
20284 auto throwScope = DECLARE_THROW_SCOPE(vm);
20285 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20286 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20287 if (!shouldAllowAccess)
20288 return jsUndefined();
20289 return JSMessageEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20290}
20291
20292JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MessageEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20293{
20294 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MessageEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20295}
20296
20297static inline JSValue jsDOMWindow_MessagePortConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20298{
20299 auto& vm = JSC::getVM(&lexicalGlobalObject);
20300 auto throwScope = DECLARE_THROW_SCOPE(vm);
20301 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20302 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20303 if (!shouldAllowAccess)
20304 return jsUndefined();
20305 return JSMessagePort::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20306}
20307
20308JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MessagePortConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20309{
20310 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MessagePortConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20311}
20312
20313static inline JSValue jsDOMWindow_MouseEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20314{
20315 auto& vm = JSC::getVM(&lexicalGlobalObject);
20316 auto throwScope = DECLARE_THROW_SCOPE(vm);
20317 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20318 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20319 if (!shouldAllowAccess)
20320 return jsUndefined();
20321 return JSMouseEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20322}
20323
20324JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MouseEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20325{
20326 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MouseEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20327}
20328
20329static inline JSValue jsDOMWindow_MutationEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20330{
20331 auto& vm = JSC::getVM(&lexicalGlobalObject);
20332 auto throwScope = DECLARE_THROW_SCOPE(vm);
20333 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20334 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20335 if (!shouldAllowAccess)
20336 return jsUndefined();
20337 return JSMutationEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20338}
20339
20340JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MutationEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20341{
20342 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MutationEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20343}
20344
20345static inline JSValue jsDOMWindow_MutationObserverConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20346{
20347 auto& vm = JSC::getVM(&lexicalGlobalObject);
20348 auto throwScope = DECLARE_THROW_SCOPE(vm);
20349 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20350 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20351 if (!shouldAllowAccess)
20352 return jsUndefined();
20353 return JSMutationObserver::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20354}
20355
20356JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MutationObserverConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20357{
20358 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MutationObserverConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20359}
20360
20361static inline JSValue jsDOMWindow_WebKitMutationObserverConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20362{
20363 auto& vm = JSC::getVM(&lexicalGlobalObject);
20364 auto throwScope = DECLARE_THROW_SCOPE(vm);
20365 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20366 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20367 if (!shouldAllowAccess)
20368 return jsUndefined();
20369 return JSMutationObserver::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20370}
20371
20372JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WebKitMutationObserverConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20373{
20374 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WebKitMutationObserverConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20375}
20376
20377static inline JSValue jsDOMWindow_MutationRecordConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20378{
20379 auto& vm = JSC::getVM(&lexicalGlobalObject);
20380 auto throwScope = DECLARE_THROW_SCOPE(vm);
20381 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20382 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20383 if (!shouldAllowAccess)
20384 return jsUndefined();
20385 return JSMutationRecord::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20386}
20387
20388JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MutationRecordConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20389{
20390 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MutationRecordConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20391}
20392
20393static inline JSValue jsDOMWindow_NamedNodeMapConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20394{
20395 auto& vm = JSC::getVM(&lexicalGlobalObject);
20396 auto throwScope = DECLARE_THROW_SCOPE(vm);
20397 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20398 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20399 if (!shouldAllowAccess)
20400 return jsUndefined();
20401 return JSNamedNodeMap::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20402}
20403
20404JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_NamedNodeMapConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20405{
20406 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_NamedNodeMapConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20407}
20408
20409static inline JSValue jsDOMWindow_NodeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20410{
20411 auto& vm = JSC::getVM(&lexicalGlobalObject);
20412 auto throwScope = DECLARE_THROW_SCOPE(vm);
20413 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20414 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20415 if (!shouldAllowAccess)
20416 return jsUndefined();
20417 return JSNode::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20418}
20419
20420JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_NodeConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20421{
20422 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_NodeConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20423}
20424
20425static inline JSValue jsDOMWindow_NodeFilterConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20426{
20427 auto& vm = JSC::getVM(&lexicalGlobalObject);
20428 auto throwScope = DECLARE_THROW_SCOPE(vm);
20429 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20430 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20431 if (!shouldAllowAccess)
20432 return jsUndefined();
20433 return JSNodeFilter::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20434}
20435
20436JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_NodeFilterConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20437{
20438 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_NodeFilterConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20439}
20440
20441static inline JSValue jsDOMWindow_NodeIteratorConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20442{
20443 auto& vm = JSC::getVM(&lexicalGlobalObject);
20444 auto throwScope = DECLARE_THROW_SCOPE(vm);
20445 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20446 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20447 if (!shouldAllowAccess)
20448 return jsUndefined();
20449 return JSNodeIterator::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20450}
20451
20452JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_NodeIteratorConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20453{
20454 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_NodeIteratorConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20455}
20456
20457static inline JSValue jsDOMWindow_NodeListConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20458{
20459 auto& vm = JSC::getVM(&lexicalGlobalObject);
20460 auto throwScope = DECLARE_THROW_SCOPE(vm);
20461 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20462 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20463 if (!shouldAllowAccess)
20464 return jsUndefined();
20465 return JSNodeList::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20466}
20467
20468JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_NodeListConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20469{
20470 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_NodeListConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20471}
20472
20473static inline JSValue jsDOMWindow_OverflowEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20474{
20475 auto& vm = JSC::getVM(&lexicalGlobalObject);
20476 auto throwScope = DECLARE_THROW_SCOPE(vm);
20477 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20478 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20479 if (!shouldAllowAccess)
20480 return jsUndefined();
20481 return JSOverflowEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20482}
20483
20484JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_OverflowEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20485{
20486 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_OverflowEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20487}
20488
20489static inline JSValue jsDOMWindow_PageTransitionEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20490{
20491 auto& vm = JSC::getVM(&lexicalGlobalObject);
20492 auto throwScope = DECLARE_THROW_SCOPE(vm);
20493 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20494 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20495 if (!shouldAllowAccess)
20496 return jsUndefined();
20497 return JSPageTransitionEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20498}
20499
20500JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_PageTransitionEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20501{
20502 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_PageTransitionEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20503}
20504
20505static inline JSValue jsDOMWindow_PointerEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20506{
20507 auto& vm = JSC::getVM(&lexicalGlobalObject);
20508 auto throwScope = DECLARE_THROW_SCOPE(vm);
20509 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20510 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20511 if (!shouldAllowAccess)
20512 return jsUndefined();
20513 return JSPointerEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20514}
20515
20516JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_PointerEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20517{
20518 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_PointerEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20519}
20520
20521static inline JSValue jsDOMWindow_PopStateEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20522{
20523 auto& vm = JSC::getVM(&lexicalGlobalObject);
20524 auto throwScope = DECLARE_THROW_SCOPE(vm);
20525 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20526 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20527 if (!shouldAllowAccess)
20528 return jsUndefined();
20529 return JSPopStateEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20530}
20531
20532JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_PopStateEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20533{
20534 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_PopStateEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20535}
20536
20537static inline JSValue jsDOMWindow_ProcessingInstructionConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20538{
20539 auto& vm = JSC::getVM(&lexicalGlobalObject);
20540 auto throwScope = DECLARE_THROW_SCOPE(vm);
20541 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20542 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20543 if (!shouldAllowAccess)
20544 return jsUndefined();
20545 return JSProcessingInstruction::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20546}
20547
20548JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ProcessingInstructionConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20549{
20550 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ProcessingInstructionConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20551}
20552
20553static inline JSValue jsDOMWindow_ProgressEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20554{
20555 auto& vm = JSC::getVM(&lexicalGlobalObject);
20556 auto throwScope = DECLARE_THROW_SCOPE(vm);
20557 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20558 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20559 if (!shouldAllowAccess)
20560 return jsUndefined();
20561 return JSProgressEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20562}
20563
20564JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ProgressEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20565{
20566 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ProgressEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20567}
20568
20569static inline JSValue jsDOMWindow_PromiseRejectionEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20570{
20571 auto& vm = JSC::getVM(&lexicalGlobalObject);
20572 auto throwScope = DECLARE_THROW_SCOPE(vm);
20573 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20574 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20575 if (!shouldAllowAccess)
20576 return jsUndefined();
20577 return JSPromiseRejectionEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20578}
20579
20580JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_PromiseRejectionEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20581{
20582 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_PromiseRejectionEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20583}
20584
20585static inline JSValue jsDOMWindow_RangeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20586{
20587 auto& vm = JSC::getVM(&lexicalGlobalObject);
20588 auto throwScope = DECLARE_THROW_SCOPE(vm);
20589 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20590 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20591 if (!shouldAllowAccess)
20592 return jsUndefined();
20593 return JSRange::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20594}
20595
20596JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_RangeConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20597{
20598 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_RangeConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20599}
20600
20601static inline JSValue jsDOMWindow_SecurityPolicyViolationEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20602{
20603 auto& vm = JSC::getVM(&lexicalGlobalObject);
20604 auto throwScope = DECLARE_THROW_SCOPE(vm);
20605 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20606 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20607 if (!shouldAllowAccess)
20608 return jsUndefined();
20609 return JSSecurityPolicyViolationEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20610}
20611
20612JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SecurityPolicyViolationEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20613{
20614 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SecurityPolicyViolationEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20615}
20616
20617static inline JSValue jsDOMWindow_ShadowRootConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20618{
20619 auto& vm = JSC::getVM(&lexicalGlobalObject);
20620 auto throwScope = DECLARE_THROW_SCOPE(vm);
20621 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20622 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20623 if (!shouldAllowAccess)
20624 return jsUndefined();
20625 return JSShadowRoot::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20626}
20627
20628JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ShadowRootConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20629{
20630 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ShadowRootConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20631}
20632
20633static inline JSValue jsDOMWindow_StaticRangeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20634{
20635 auto& vm = JSC::getVM(&lexicalGlobalObject);
20636 auto throwScope = DECLARE_THROW_SCOPE(vm);
20637 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20638 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20639 if (!shouldAllowAccess)
20640 return jsUndefined();
20641 return JSStaticRange::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20642}
20643
20644JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_StaticRangeConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20645{
20646 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_StaticRangeConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20647}
20648
20649static inline JSValue jsDOMWindow_TextConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20650{
20651 auto& vm = JSC::getVM(&lexicalGlobalObject);
20652 auto throwScope = DECLARE_THROW_SCOPE(vm);
20653 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20654 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20655 if (!shouldAllowAccess)
20656 return jsUndefined();
20657 return JSText::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20658}
20659
20660JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_TextConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20661{
20662 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_TextConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20663}
20664
20665static inline JSValue jsDOMWindow_TextDecoderConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20666{
20667 auto& vm = JSC::getVM(&lexicalGlobalObject);
20668 auto throwScope = DECLARE_THROW_SCOPE(vm);
20669 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20670 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20671 if (!shouldAllowAccess)
20672 return jsUndefined();
20673 return JSTextDecoder::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20674}
20675
20676JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_TextDecoderConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20677{
20678 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_TextDecoderConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20679}
20680
20681static inline JSValue jsDOMWindow_TextDecoderStreamConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20682{
20683 auto& vm = JSC::getVM(&lexicalGlobalObject);
20684 auto throwScope = DECLARE_THROW_SCOPE(vm);
20685 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20686 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20687 if (!shouldAllowAccess)
20688 return jsUndefined();
20689 return JSTextDecoderStream::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20690}
20691
20692JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_TextDecoderStreamConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20693{
20694 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_TextDecoderStreamConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20695}
20696
20697static inline JSValue jsDOMWindow_TextDecoderStreamDecoderConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20698{
20699 auto& vm = JSC::getVM(&lexicalGlobalObject);
20700 auto throwScope = DECLARE_THROW_SCOPE(vm);
20701 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20702 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20703 if (!shouldAllowAccess)
20704 return jsUndefined();
20705 return JSTextDecoderStreamDecoder::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20706}
20707
20708JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_TextDecoderStreamDecoderConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20709{
20710 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_TextDecoderStreamDecoderConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20711}
20712
20713static inline JSValue jsDOMWindow_TextEncoderConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20714{
20715 auto& vm = JSC::getVM(&lexicalGlobalObject);
20716 auto throwScope = DECLARE_THROW_SCOPE(vm);
20717 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20718 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20719 if (!shouldAllowAccess)
20720 return jsUndefined();
20721 return JSTextEncoder::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20722}
20723
20724JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_TextEncoderConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20725{
20726 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_TextEncoderConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20727}
20728
20729static inline JSValue jsDOMWindow_TextEncoderStreamConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20730{
20731 auto& vm = JSC::getVM(&lexicalGlobalObject);
20732 auto throwScope = DECLARE_THROW_SCOPE(vm);
20733 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20734 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20735 if (!shouldAllowAccess)
20736 return jsUndefined();
20737 return JSTextEncoderStream::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20738}
20739
20740JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_TextEncoderStreamConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20741{
20742 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_TextEncoderStreamConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20743}
20744
20745static inline JSValue jsDOMWindow_TextEncoderStreamEncoderConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20746{
20747 auto& vm = JSC::getVM(&lexicalGlobalObject);
20748 auto throwScope = DECLARE_THROW_SCOPE(vm);
20749 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20750 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20751 if (!shouldAllowAccess)
20752 return jsUndefined();
20753 return JSTextEncoderStreamEncoder::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20754}
20755
20756JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_TextEncoderStreamEncoderConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20757{
20758 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_TextEncoderStreamEncoderConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20759}
20760
20761static inline JSValue jsDOMWindow_TextEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20762{
20763 auto& vm = JSC::getVM(&lexicalGlobalObject);
20764 auto throwScope = DECLARE_THROW_SCOPE(vm);
20765 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20766 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20767 if (!shouldAllowAccess)
20768 return jsUndefined();
20769 return JSTextEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20770}
20771
20772JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_TextEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20773{
20774 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_TextEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20775}
20776
20777static inline JSValue jsDOMWindow_TransitionEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20778{
20779 auto& vm = JSC::getVM(&lexicalGlobalObject);
20780 auto throwScope = DECLARE_THROW_SCOPE(vm);
20781 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20782 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20783 if (!shouldAllowAccess)
20784 return jsUndefined();
20785 return JSTransitionEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20786}
20787
20788JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_TransitionEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20789{
20790 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_TransitionEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20791}
20792
20793static inline JSValue jsDOMWindow_TreeWalkerConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20794{
20795 auto& vm = JSC::getVM(&lexicalGlobalObject);
20796 auto throwScope = DECLARE_THROW_SCOPE(vm);
20797 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20798 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20799 if (!shouldAllowAccess)
20800 return jsUndefined();
20801 return JSTreeWalker::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20802}
20803
20804JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_TreeWalkerConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20805{
20806 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_TreeWalkerConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20807}
20808
20809static inline JSValue jsDOMWindow_UIEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20810{
20811 auto& vm = JSC::getVM(&lexicalGlobalObject);
20812 auto throwScope = DECLARE_THROW_SCOPE(vm);
20813 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20814 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20815 if (!shouldAllowAccess)
20816 return jsUndefined();
20817 return JSUIEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20818}
20819
20820JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_UIEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20821{
20822 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_UIEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20823}
20824
20825static inline JSValue jsDOMWindow_WebKitAnimationEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20826{
20827 auto& vm = JSC::getVM(&lexicalGlobalObject);
20828 auto throwScope = DECLARE_THROW_SCOPE(vm);
20829 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20830 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20831 if (!shouldAllowAccess)
20832 return jsUndefined();
20833 return JSWebKitAnimationEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20834}
20835
20836JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WebKitAnimationEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20837{
20838 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WebKitAnimationEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20839}
20840
20841static inline JSValue jsDOMWindow_WebKitTransitionEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20842{
20843 auto& vm = JSC::getVM(&lexicalGlobalObject);
20844 auto throwScope = DECLARE_THROW_SCOPE(vm);
20845 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20846 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20847 if (!shouldAllowAccess)
20848 return jsUndefined();
20849 return JSWebKitTransitionEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20850}
20851
20852JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WebKitTransitionEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20853{
20854 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WebKitTransitionEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20855}
20856
20857static inline JSValue jsDOMWindow_WheelEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20858{
20859 auto& vm = JSC::getVM(&lexicalGlobalObject);
20860 auto throwScope = DECLARE_THROW_SCOPE(vm);
20861 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20862 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20863 if (!shouldAllowAccess)
20864 return jsUndefined();
20865 return JSWheelEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20866}
20867
20868JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WheelEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20869{
20870 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WheelEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20871}
20872
20873static inline JSValue jsDOMWindow_XMLDocumentConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20874{
20875 auto& vm = JSC::getVM(&lexicalGlobalObject);
20876 auto throwScope = DECLARE_THROW_SCOPE(vm);
20877 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20878 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20879 if (!shouldAllowAccess)
20880 return jsUndefined();
20881 return JSXMLDocument::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20882}
20883
20884JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_XMLDocumentConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20885{
20886 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_XMLDocumentConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20887}
20888
20889static inline JSValue jsDOMWindow_SVGDocumentConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20890{
20891 auto& vm = JSC::getVM(&lexicalGlobalObject);
20892 auto throwScope = DECLARE_THROW_SCOPE(vm);
20893 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20894 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20895 if (!shouldAllowAccess)
20896 return jsUndefined();
20897 return JSXMLDocument::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20898}
20899
20900JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGDocumentConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20901{
20902 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGDocumentConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20903}
20904
20905static inline JSValue jsDOMWindow_BlobConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20906{
20907 auto& vm = JSC::getVM(&lexicalGlobalObject);
20908 auto throwScope = DECLARE_THROW_SCOPE(vm);
20909 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20910 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20911 if (!shouldAllowAccess)
20912 return jsUndefined();
20913 return JSBlob::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20914}
20915
20916JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_BlobConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20917{
20918 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_BlobConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20919}
20920
20921static inline JSValue jsDOMWindow_FileConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20922{
20923 auto& vm = JSC::getVM(&lexicalGlobalObject);
20924 auto throwScope = DECLARE_THROW_SCOPE(vm);
20925 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20926 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20927 if (!shouldAllowAccess)
20928 return jsUndefined();
20929 return JSFile::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20930}
20931
20932JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_FileConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20933{
20934 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_FileConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20935}
20936
20937static inline JSValue jsDOMWindow_FileListConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20938{
20939 auto& vm = JSC::getVM(&lexicalGlobalObject);
20940 auto throwScope = DECLARE_THROW_SCOPE(vm);
20941 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20942 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20943 if (!shouldAllowAccess)
20944 return jsUndefined();
20945 return JSFileList::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20946}
20947
20948JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_FileListConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20949{
20950 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_FileListConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20951}
20952
20953static inline JSValue jsDOMWindow_FileReaderConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20954{
20955 auto& vm = JSC::getVM(&lexicalGlobalObject);
20956 auto throwScope = DECLARE_THROW_SCOPE(vm);
20957 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20958 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20959 if (!shouldAllowAccess)
20960 return jsUndefined();
20961 return JSFileReader::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20962}
20963
20964JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_FileReaderConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20965{
20966 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_FileReaderConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20967}
20968
20969static inline JSValue jsDOMWindow_FormDataConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20970{
20971 auto& vm = JSC::getVM(&lexicalGlobalObject);
20972 auto throwScope = DECLARE_THROW_SCOPE(vm);
20973 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20974 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20975 if (!shouldAllowAccess)
20976 return jsUndefined();
20977 return JSDOMFormData::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20978}
20979
20980JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_FormDataConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20981{
20982 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_FormDataConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20983}
20984
20985static inline JSValue jsDOMWindow_DOMTokenListConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
20986{
20987 auto& vm = JSC::getVM(&lexicalGlobalObject);
20988 auto throwScope = DECLARE_THROW_SCOPE(vm);
20989 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
20990 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
20991 if (!shouldAllowAccess)
20992 return jsUndefined();
20993 return JSDOMTokenList::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
20994}
20995
20996JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_DOMTokenListConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
20997{
20998 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_DOMTokenListConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
20999}
21000
21001static inline JSValue jsDOMWindow_URLConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21002{
21003 auto& vm = JSC::getVM(&lexicalGlobalObject);
21004 auto throwScope = DECLARE_THROW_SCOPE(vm);
21005 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21006 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21007 if (!shouldAllowAccess)
21008 return jsUndefined();
21009 return JSDOMURL::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21010}
21011
21012JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_URLConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21013{
21014 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_URLConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21015}
21016
21017static inline JSValue jsDOMWindow_webkitURLConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21018{
21019 auto& vm = JSC::getVM(&lexicalGlobalObject);
21020 auto throwScope = DECLARE_THROW_SCOPE(vm);
21021 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21022 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21023 if (!shouldAllowAccess)
21024 return jsUndefined();
21025 return JSDOMURL::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21026}
21027
21028JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_webkitURLConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21029{
21030 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_webkitURLConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21031}
21032
21033static inline JSValue jsDOMWindow_HTMLAllCollectionConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21034{
21035 auto& vm = JSC::getVM(&lexicalGlobalObject);
21036 auto throwScope = DECLARE_THROW_SCOPE(vm);
21037 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21038 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21039 if (!shouldAllowAccess)
21040 return jsUndefined();
21041 return JSHTMLAllCollection::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21042}
21043
21044JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLAllCollectionConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21045{
21046 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLAllCollectionConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21047}
21048
21049static inline JSValue jsDOMWindow_HTMLAnchorElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21050{
21051 auto& vm = JSC::getVM(&lexicalGlobalObject);
21052 auto throwScope = DECLARE_THROW_SCOPE(vm);
21053 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21054 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21055 if (!shouldAllowAccess)
21056 return jsUndefined();
21057 return JSHTMLAnchorElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21058}
21059
21060JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLAnchorElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21061{
21062 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLAnchorElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21063}
21064
21065static inline JSValue jsDOMWindow_HTMLAreaElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21066{
21067 auto& vm = JSC::getVM(&lexicalGlobalObject);
21068 auto throwScope = DECLARE_THROW_SCOPE(vm);
21069 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21070 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21071 if (!shouldAllowAccess)
21072 return jsUndefined();
21073 return JSHTMLAreaElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21074}
21075
21076JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLAreaElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21077{
21078 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLAreaElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21079}
21080
21081#if ENABLE(ATTACHMENT_ELEMENT)
21082static inline JSValue jsDOMWindow_HTMLAttachmentElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21083{
21084 auto& vm = JSC::getVM(&lexicalGlobalObject);
21085 auto throwScope = DECLARE_THROW_SCOPE(vm);
21086 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21087 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21088 if (!shouldAllowAccess)
21089 return jsUndefined();
21090 return JSHTMLAttachmentElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21091}
21092
21093JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLAttachmentElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21094{
21095 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLAttachmentElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21096}
21097
21098#endif
21099
21100#if ENABLE(VIDEO)
21101static inline JSValue jsDOMWindow_HTMLAudioElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21102{
21103 auto& vm = JSC::getVM(&lexicalGlobalObject);
21104 auto throwScope = DECLARE_THROW_SCOPE(vm);
21105 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21106 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21107 if (!shouldAllowAccess)
21108 return jsUndefined();
21109 return JSHTMLAudioElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21110}
21111
21112JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLAudioElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21113{
21114 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLAudioElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21115}
21116
21117#endif
21118
21119#if ENABLE(VIDEO)
21120static inline JSValue jsDOMWindow_AudioConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21121{
21122 auto& vm = JSC::getVM(&lexicalGlobalObject);
21123 auto throwScope = DECLARE_THROW_SCOPE(vm);
21124 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21125 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21126 if (!shouldAllowAccess)
21127 return jsUndefined();
21128 return JSHTMLAudioElement::getLegacyFactoryFunction(JSC::getVM(&lexicalGlobalObject), &thisObject);
21129}
21130
21131JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_AudioConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21132{
21133 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_AudioConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21134}
21135
21136#endif
21137
21138static inline JSValue jsDOMWindow_HTMLBRElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21139{
21140 auto& vm = JSC::getVM(&lexicalGlobalObject);
21141 auto throwScope = DECLARE_THROW_SCOPE(vm);
21142 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21143 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21144 if (!shouldAllowAccess)
21145 return jsUndefined();
21146 return JSHTMLBRElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21147}
21148
21149JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLBRElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21150{
21151 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLBRElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21152}
21153
21154static inline JSValue jsDOMWindow_HTMLBaseElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21155{
21156 auto& vm = JSC::getVM(&lexicalGlobalObject);
21157 auto throwScope = DECLARE_THROW_SCOPE(vm);
21158 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21159 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21160 if (!shouldAllowAccess)
21161 return jsUndefined();
21162 return JSHTMLBaseElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21163}
21164
21165JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLBaseElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21166{
21167 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLBaseElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21168}
21169
21170static inline JSValue jsDOMWindow_HTMLBodyElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21171{
21172 auto& vm = JSC::getVM(&lexicalGlobalObject);
21173 auto throwScope = DECLARE_THROW_SCOPE(vm);
21174 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21175 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21176 if (!shouldAllowAccess)
21177 return jsUndefined();
21178 return JSHTMLBodyElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21179}
21180
21181JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLBodyElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21182{
21183 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLBodyElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21184}
21185
21186static inline JSValue jsDOMWindow_HTMLButtonElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21187{
21188 auto& vm = JSC::getVM(&lexicalGlobalObject);
21189 auto throwScope = DECLARE_THROW_SCOPE(vm);
21190 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21191 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21192 if (!shouldAllowAccess)
21193 return jsUndefined();
21194 return JSHTMLButtonElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21195}
21196
21197JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLButtonElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21198{
21199 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLButtonElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21200}
21201
21202static inline JSValue jsDOMWindow_HTMLCanvasElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21203{
21204 auto& vm = JSC::getVM(&lexicalGlobalObject);
21205 auto throwScope = DECLARE_THROW_SCOPE(vm);
21206 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21207 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21208 if (!shouldAllowAccess)
21209 return jsUndefined();
21210 return JSHTMLCanvasElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21211}
21212
21213JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLCanvasElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21214{
21215 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLCanvasElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21216}
21217
21218static inline JSValue jsDOMWindow_HTMLCollectionConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21219{
21220 auto& vm = JSC::getVM(&lexicalGlobalObject);
21221 auto throwScope = DECLARE_THROW_SCOPE(vm);
21222 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21223 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21224 if (!shouldAllowAccess)
21225 return jsUndefined();
21226 return JSHTMLCollection::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21227}
21228
21229JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLCollectionConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21230{
21231 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLCollectionConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21232}
21233
21234static inline JSValue jsDOMWindow_HTMLDListElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21235{
21236 auto& vm = JSC::getVM(&lexicalGlobalObject);
21237 auto throwScope = DECLARE_THROW_SCOPE(vm);
21238 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21239 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21240 if (!shouldAllowAccess)
21241 return jsUndefined();
21242 return JSHTMLDListElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21243}
21244
21245JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLDListElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21246{
21247 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLDListElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21248}
21249
21250static inline JSValue jsDOMWindow_HTMLDataElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21251{
21252 auto& vm = JSC::getVM(&lexicalGlobalObject);
21253 auto throwScope = DECLARE_THROW_SCOPE(vm);
21254 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21255 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21256 if (!shouldAllowAccess)
21257 return jsUndefined();
21258 return JSHTMLDataElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21259}
21260
21261JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLDataElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21262{
21263 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLDataElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21264}
21265
21266#if ENABLE(DATALIST_ELEMENT)
21267static inline JSValue jsDOMWindow_HTMLDataListElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21268{
21269 auto& vm = JSC::getVM(&lexicalGlobalObject);
21270 auto throwScope = DECLARE_THROW_SCOPE(vm);
21271 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21272 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21273 if (!shouldAllowAccess)
21274 return jsUndefined();
21275 return JSHTMLDataListElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21276}
21277
21278JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLDataListElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21279{
21280 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLDataListElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21281}
21282
21283#endif
21284
21285static inline JSValue jsDOMWindow_HTMLDetailsElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21286{
21287 auto& vm = JSC::getVM(&lexicalGlobalObject);
21288 auto throwScope = DECLARE_THROW_SCOPE(vm);
21289 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21290 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21291 if (!shouldAllowAccess)
21292 return jsUndefined();
21293 return JSHTMLDetailsElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21294}
21295
21296JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLDetailsElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21297{
21298 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLDetailsElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21299}
21300
21301static inline JSValue jsDOMWindow_HTMLDialogElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21302{
21303 auto& vm = JSC::getVM(&lexicalGlobalObject);
21304 auto throwScope = DECLARE_THROW_SCOPE(vm);
21305 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21306 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21307 if (!shouldAllowAccess)
21308 return jsUndefined();
21309 return JSHTMLDialogElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21310}
21311
21312JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLDialogElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21313{
21314 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLDialogElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21315}
21316
21317static inline JSValue jsDOMWindow_HTMLDirectoryElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21318{
21319 auto& vm = JSC::getVM(&lexicalGlobalObject);
21320 auto throwScope = DECLARE_THROW_SCOPE(vm);
21321 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21322 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21323 if (!shouldAllowAccess)
21324 return jsUndefined();
21325 return JSHTMLDirectoryElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21326}
21327
21328JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLDirectoryElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21329{
21330 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLDirectoryElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21331}
21332
21333static inline JSValue jsDOMWindow_HTMLDivElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21334{
21335 auto& vm = JSC::getVM(&lexicalGlobalObject);
21336 auto throwScope = DECLARE_THROW_SCOPE(vm);
21337 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21338 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21339 if (!shouldAllowAccess)
21340 return jsUndefined();
21341 return JSHTMLDivElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21342}
21343
21344JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLDivElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21345{
21346 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLDivElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21347}
21348
21349static inline JSValue jsDOMWindow_HTMLDocumentConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21350{
21351 auto& vm = JSC::getVM(&lexicalGlobalObject);
21352 auto throwScope = DECLARE_THROW_SCOPE(vm);
21353 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21354 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21355 if (!shouldAllowAccess)
21356 return jsUndefined();
21357 return JSHTMLDocument::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21358}
21359
21360JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLDocumentConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21361{
21362 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLDocumentConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21363}
21364
21365static inline JSValue jsDOMWindow_HTMLElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21366{
21367 auto& vm = JSC::getVM(&lexicalGlobalObject);
21368 auto throwScope = DECLARE_THROW_SCOPE(vm);
21369 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21370 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21371 if (!shouldAllowAccess)
21372 return jsUndefined();
21373 return JSHTMLElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21374}
21375
21376JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21377{
21378 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21379}
21380
21381static inline JSValue jsDOMWindow_HTMLEmbedElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21382{
21383 auto& vm = JSC::getVM(&lexicalGlobalObject);
21384 auto throwScope = DECLARE_THROW_SCOPE(vm);
21385 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21386 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21387 if (!shouldAllowAccess)
21388 return jsUndefined();
21389 return JSHTMLEmbedElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21390}
21391
21392JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLEmbedElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21393{
21394 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLEmbedElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21395}
21396
21397static inline JSValue jsDOMWindow_HTMLFieldSetElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21398{
21399 auto& vm = JSC::getVM(&lexicalGlobalObject);
21400 auto throwScope = DECLARE_THROW_SCOPE(vm);
21401 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21402 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21403 if (!shouldAllowAccess)
21404 return jsUndefined();
21405 return JSHTMLFieldSetElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21406}
21407
21408JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLFieldSetElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21409{
21410 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLFieldSetElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21411}
21412
21413static inline JSValue jsDOMWindow_HTMLFontElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21414{
21415 auto& vm = JSC::getVM(&lexicalGlobalObject);
21416 auto throwScope = DECLARE_THROW_SCOPE(vm);
21417 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21418 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21419 if (!shouldAllowAccess)
21420 return jsUndefined();
21421 return JSHTMLFontElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21422}
21423
21424JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLFontElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21425{
21426 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLFontElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21427}
21428
21429static inline JSValue jsDOMWindow_HTMLFormControlsCollectionConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21430{
21431 auto& vm = JSC::getVM(&lexicalGlobalObject);
21432 auto throwScope = DECLARE_THROW_SCOPE(vm);
21433 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21434 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21435 if (!shouldAllowAccess)
21436 return jsUndefined();
21437 return JSHTMLFormControlsCollection::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21438}
21439
21440JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLFormControlsCollectionConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21441{
21442 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLFormControlsCollectionConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21443}
21444
21445static inline JSValue jsDOMWindow_HTMLFormElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21446{
21447 auto& vm = JSC::getVM(&lexicalGlobalObject);
21448 auto throwScope = DECLARE_THROW_SCOPE(vm);
21449 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21450 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21451 if (!shouldAllowAccess)
21452 return jsUndefined();
21453 return JSHTMLFormElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21454}
21455
21456JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLFormElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21457{
21458 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLFormElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21459}
21460
21461static inline JSValue jsDOMWindow_HTMLFrameElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21462{
21463 auto& vm = JSC::getVM(&lexicalGlobalObject);
21464 auto throwScope = DECLARE_THROW_SCOPE(vm);
21465 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21466 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21467 if (!shouldAllowAccess)
21468 return jsUndefined();
21469 return JSHTMLFrameElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21470}
21471
21472JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLFrameElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21473{
21474 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLFrameElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21475}
21476
21477static inline JSValue jsDOMWindow_HTMLFrameSetElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21478{
21479 auto& vm = JSC::getVM(&lexicalGlobalObject);
21480 auto throwScope = DECLARE_THROW_SCOPE(vm);
21481 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21482 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21483 if (!shouldAllowAccess)
21484 return jsUndefined();
21485 return JSHTMLFrameSetElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21486}
21487
21488JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLFrameSetElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21489{
21490 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLFrameSetElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21491}
21492
21493static inline JSValue jsDOMWindow_HTMLHRElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21494{
21495 auto& vm = JSC::getVM(&lexicalGlobalObject);
21496 auto throwScope = DECLARE_THROW_SCOPE(vm);
21497 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21498 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21499 if (!shouldAllowAccess)
21500 return jsUndefined();
21501 return JSHTMLHRElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21502}
21503
21504JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLHRElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21505{
21506 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLHRElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21507}
21508
21509static inline JSValue jsDOMWindow_HTMLHeadElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21510{
21511 auto& vm = JSC::getVM(&lexicalGlobalObject);
21512 auto throwScope = DECLARE_THROW_SCOPE(vm);
21513 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21514 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21515 if (!shouldAllowAccess)
21516 return jsUndefined();
21517 return JSHTMLHeadElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21518}
21519
21520JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLHeadElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21521{
21522 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLHeadElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21523}
21524
21525static inline JSValue jsDOMWindow_HTMLHeadingElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21526{
21527 auto& vm = JSC::getVM(&lexicalGlobalObject);
21528 auto throwScope = DECLARE_THROW_SCOPE(vm);
21529 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21530 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21531 if (!shouldAllowAccess)
21532 return jsUndefined();
21533 return JSHTMLHeadingElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21534}
21535
21536JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLHeadingElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21537{
21538 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLHeadingElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21539}
21540
21541static inline JSValue jsDOMWindow_HTMLHtmlElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21542{
21543 auto& vm = JSC::getVM(&lexicalGlobalObject);
21544 auto throwScope = DECLARE_THROW_SCOPE(vm);
21545 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21546 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21547 if (!shouldAllowAccess)
21548 return jsUndefined();
21549 return JSHTMLHtmlElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21550}
21551
21552JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLHtmlElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21553{
21554 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLHtmlElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21555}
21556
21557static inline JSValue jsDOMWindow_HTMLIFrameElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21558{
21559 auto& vm = JSC::getVM(&lexicalGlobalObject);
21560 auto throwScope = DECLARE_THROW_SCOPE(vm);
21561 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21562 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21563 if (!shouldAllowAccess)
21564 return jsUndefined();
21565 return JSHTMLIFrameElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21566}
21567
21568JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLIFrameElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21569{
21570 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLIFrameElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21571}
21572
21573static inline JSValue jsDOMWindow_HTMLImageElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21574{
21575 auto& vm = JSC::getVM(&lexicalGlobalObject);
21576 auto throwScope = DECLARE_THROW_SCOPE(vm);
21577 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21578 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21579 if (!shouldAllowAccess)
21580 return jsUndefined();
21581 return JSHTMLImageElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21582}
21583
21584JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLImageElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21585{
21586 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLImageElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21587}
21588
21589static inline JSValue jsDOMWindow_ImageConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21590{
21591 auto& vm = JSC::getVM(&lexicalGlobalObject);
21592 auto throwScope = DECLARE_THROW_SCOPE(vm);
21593 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21594 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21595 if (!shouldAllowAccess)
21596 return jsUndefined();
21597 return JSHTMLImageElement::getLegacyFactoryFunction(JSC::getVM(&lexicalGlobalObject), &thisObject);
21598}
21599
21600JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ImageConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21601{
21602 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ImageConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21603}
21604
21605static inline JSValue jsDOMWindow_HTMLInputElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21606{
21607 auto& vm = JSC::getVM(&lexicalGlobalObject);
21608 auto throwScope = DECLARE_THROW_SCOPE(vm);
21609 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21610 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21611 if (!shouldAllowAccess)
21612 return jsUndefined();
21613 return JSHTMLInputElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21614}
21615
21616JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLInputElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21617{
21618 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLInputElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21619}
21620
21621static inline JSValue jsDOMWindow_HTMLKeygenElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21622{
21623 auto& vm = JSC::getVM(&lexicalGlobalObject);
21624 auto throwScope = DECLARE_THROW_SCOPE(vm);
21625 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21626 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21627 if (!shouldAllowAccess)
21628 return jsUndefined();
21629 return JSHTMLKeygenElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21630}
21631
21632JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLKeygenElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21633{
21634 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLKeygenElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21635}
21636
21637static inline JSValue jsDOMWindow_HTMLLIElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21638{
21639 auto& vm = JSC::getVM(&lexicalGlobalObject);
21640 auto throwScope = DECLARE_THROW_SCOPE(vm);
21641 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21642 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21643 if (!shouldAllowAccess)
21644 return jsUndefined();
21645 return JSHTMLLIElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21646}
21647
21648JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLLIElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21649{
21650 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLLIElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21651}
21652
21653static inline JSValue jsDOMWindow_HTMLLabelElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21654{
21655 auto& vm = JSC::getVM(&lexicalGlobalObject);
21656 auto throwScope = DECLARE_THROW_SCOPE(vm);
21657 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21658 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21659 if (!shouldAllowAccess)
21660 return jsUndefined();
21661 return JSHTMLLabelElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21662}
21663
21664JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLLabelElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21665{
21666 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLLabelElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21667}
21668
21669static inline JSValue jsDOMWindow_HTMLLegendElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21670{
21671 auto& vm = JSC::getVM(&lexicalGlobalObject);
21672 auto throwScope = DECLARE_THROW_SCOPE(vm);
21673 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21674 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21675 if (!shouldAllowAccess)
21676 return jsUndefined();
21677 return JSHTMLLegendElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21678}
21679
21680JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLLegendElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21681{
21682 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLLegendElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21683}
21684
21685static inline JSValue jsDOMWindow_HTMLLinkElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21686{
21687 auto& vm = JSC::getVM(&lexicalGlobalObject);
21688 auto throwScope = DECLARE_THROW_SCOPE(vm);
21689 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21690 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21691 if (!shouldAllowAccess)
21692 return jsUndefined();
21693 return JSHTMLLinkElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21694}
21695
21696JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLLinkElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21697{
21698 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLLinkElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21699}
21700
21701static inline JSValue jsDOMWindow_HTMLMapElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21702{
21703 auto& vm = JSC::getVM(&lexicalGlobalObject);
21704 auto throwScope = DECLARE_THROW_SCOPE(vm);
21705 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21706 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21707 if (!shouldAllowAccess)
21708 return jsUndefined();
21709 return JSHTMLMapElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21710}
21711
21712JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLMapElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21713{
21714 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLMapElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21715}
21716
21717static inline JSValue jsDOMWindow_HTMLMarqueeElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21718{
21719 auto& vm = JSC::getVM(&lexicalGlobalObject);
21720 auto throwScope = DECLARE_THROW_SCOPE(vm);
21721 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21722 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21723 if (!shouldAllowAccess)
21724 return jsUndefined();
21725 return JSHTMLMarqueeElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21726}
21727
21728JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLMarqueeElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21729{
21730 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLMarqueeElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21731}
21732
21733#if ENABLE(VIDEO)
21734static inline JSValue jsDOMWindow_HTMLMediaElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21735{
21736 auto& vm = JSC::getVM(&lexicalGlobalObject);
21737 auto throwScope = DECLARE_THROW_SCOPE(vm);
21738 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21739 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21740 if (!shouldAllowAccess)
21741 return jsUndefined();
21742 return JSHTMLMediaElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21743}
21744
21745JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLMediaElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21746{
21747 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLMediaElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21748}
21749
21750#endif
21751
21752static inline JSValue jsDOMWindow_HTMLMenuElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21753{
21754 auto& vm = JSC::getVM(&lexicalGlobalObject);
21755 auto throwScope = DECLARE_THROW_SCOPE(vm);
21756 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21757 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21758 if (!shouldAllowAccess)
21759 return jsUndefined();
21760 return JSHTMLMenuElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21761}
21762
21763JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLMenuElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21764{
21765 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLMenuElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21766}
21767
21768static inline JSValue jsDOMWindow_HTMLMenuItemElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21769{
21770 auto& vm = JSC::getVM(&lexicalGlobalObject);
21771 auto throwScope = DECLARE_THROW_SCOPE(vm);
21772 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21773 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21774 if (!shouldAllowAccess)
21775 return jsUndefined();
21776 return JSHTMLMenuItemElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21777}
21778
21779JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLMenuItemElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21780{
21781 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLMenuItemElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21782}
21783
21784static inline JSValue jsDOMWindow_HTMLMetaElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21785{
21786 auto& vm = JSC::getVM(&lexicalGlobalObject);
21787 auto throwScope = DECLARE_THROW_SCOPE(vm);
21788 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21789 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21790 if (!shouldAllowAccess)
21791 return jsUndefined();
21792 return JSHTMLMetaElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21793}
21794
21795JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLMetaElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21796{
21797 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLMetaElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21798}
21799
21800static inline JSValue jsDOMWindow_HTMLMeterElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21801{
21802 auto& vm = JSC::getVM(&lexicalGlobalObject);
21803 auto throwScope = DECLARE_THROW_SCOPE(vm);
21804 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21805 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21806 if (!shouldAllowAccess)
21807 return jsUndefined();
21808 return JSHTMLMeterElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21809}
21810
21811JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLMeterElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21812{
21813 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLMeterElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21814}
21815
21816static inline JSValue jsDOMWindow_HTMLModElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21817{
21818 auto& vm = JSC::getVM(&lexicalGlobalObject);
21819 auto throwScope = DECLARE_THROW_SCOPE(vm);
21820 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21821 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21822 if (!shouldAllowAccess)
21823 return jsUndefined();
21824 return JSHTMLModElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21825}
21826
21827JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLModElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21828{
21829 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLModElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21830}
21831
21832static inline JSValue jsDOMWindow_HTMLOListElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21833{
21834 auto& vm = JSC::getVM(&lexicalGlobalObject);
21835 auto throwScope = DECLARE_THROW_SCOPE(vm);
21836 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21837 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21838 if (!shouldAllowAccess)
21839 return jsUndefined();
21840 return JSHTMLOListElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21841}
21842
21843JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLOListElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21844{
21845 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLOListElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21846}
21847
21848static inline JSValue jsDOMWindow_HTMLObjectElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21849{
21850 auto& vm = JSC::getVM(&lexicalGlobalObject);
21851 auto throwScope = DECLARE_THROW_SCOPE(vm);
21852 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21853 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21854 if (!shouldAllowAccess)
21855 return jsUndefined();
21856 return JSHTMLObjectElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21857}
21858
21859JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLObjectElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21860{
21861 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLObjectElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21862}
21863
21864static inline JSValue jsDOMWindow_HTMLOptGroupElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21865{
21866 auto& vm = JSC::getVM(&lexicalGlobalObject);
21867 auto throwScope = DECLARE_THROW_SCOPE(vm);
21868 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21869 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21870 if (!shouldAllowAccess)
21871 return jsUndefined();
21872 return JSHTMLOptGroupElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21873}
21874
21875JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLOptGroupElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21876{
21877 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLOptGroupElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21878}
21879
21880static inline JSValue jsDOMWindow_HTMLOptionElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21881{
21882 auto& vm = JSC::getVM(&lexicalGlobalObject);
21883 auto throwScope = DECLARE_THROW_SCOPE(vm);
21884 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21885 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21886 if (!shouldAllowAccess)
21887 return jsUndefined();
21888 return JSHTMLOptionElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21889}
21890
21891JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLOptionElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21892{
21893 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLOptionElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21894}
21895
21896static inline JSValue jsDOMWindow_OptionConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21897{
21898 auto& vm = JSC::getVM(&lexicalGlobalObject);
21899 auto throwScope = DECLARE_THROW_SCOPE(vm);
21900 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21901 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21902 if (!shouldAllowAccess)
21903 return jsUndefined();
21904 return JSHTMLOptionElement::getLegacyFactoryFunction(JSC::getVM(&lexicalGlobalObject), &thisObject);
21905}
21906
21907JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_OptionConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21908{
21909 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_OptionConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21910}
21911
21912static inline JSValue jsDOMWindow_HTMLOptionsCollectionConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21913{
21914 auto& vm = JSC::getVM(&lexicalGlobalObject);
21915 auto throwScope = DECLARE_THROW_SCOPE(vm);
21916 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21917 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21918 if (!shouldAllowAccess)
21919 return jsUndefined();
21920 return JSHTMLOptionsCollection::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21921}
21922
21923JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLOptionsCollectionConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21924{
21925 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLOptionsCollectionConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21926}
21927
21928static inline JSValue jsDOMWindow_HTMLOutputElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21929{
21930 auto& vm = JSC::getVM(&lexicalGlobalObject);
21931 auto throwScope = DECLARE_THROW_SCOPE(vm);
21932 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21933 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21934 if (!shouldAllowAccess)
21935 return jsUndefined();
21936 return JSHTMLOutputElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21937}
21938
21939JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLOutputElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21940{
21941 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLOutputElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21942}
21943
21944static inline JSValue jsDOMWindow_HTMLParagraphElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21945{
21946 auto& vm = JSC::getVM(&lexicalGlobalObject);
21947 auto throwScope = DECLARE_THROW_SCOPE(vm);
21948 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21949 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21950 if (!shouldAllowAccess)
21951 return jsUndefined();
21952 return JSHTMLParagraphElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21953}
21954
21955JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLParagraphElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21956{
21957 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLParagraphElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21958}
21959
21960static inline JSValue jsDOMWindow_HTMLParamElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21961{
21962 auto& vm = JSC::getVM(&lexicalGlobalObject);
21963 auto throwScope = DECLARE_THROW_SCOPE(vm);
21964 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21965 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21966 if (!shouldAllowAccess)
21967 return jsUndefined();
21968 return JSHTMLParamElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21969}
21970
21971JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLParamElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21972{
21973 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLParamElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21974}
21975
21976static inline JSValue jsDOMWindow_HTMLPictureElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21977{
21978 auto& vm = JSC::getVM(&lexicalGlobalObject);
21979 auto throwScope = DECLARE_THROW_SCOPE(vm);
21980 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21981 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21982 if (!shouldAllowAccess)
21983 return jsUndefined();
21984 return JSHTMLPictureElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
21985}
21986
21987JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLPictureElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
21988{
21989 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLPictureElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
21990}
21991
21992static inline JSValue jsDOMWindow_HTMLPreElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
21993{
21994 auto& vm = JSC::getVM(&lexicalGlobalObject);
21995 auto throwScope = DECLARE_THROW_SCOPE(vm);
21996 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
21997 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
21998 if (!shouldAllowAccess)
21999 return jsUndefined();
22000 return JSHTMLPreElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22001}
22002
22003JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLPreElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22004{
22005 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLPreElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22006}
22007
22008static inline JSValue jsDOMWindow_HTMLProgressElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22009{
22010 auto& vm = JSC::getVM(&lexicalGlobalObject);
22011 auto throwScope = DECLARE_THROW_SCOPE(vm);
22012 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22013 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22014 if (!shouldAllowAccess)
22015 return jsUndefined();
22016 return JSHTMLProgressElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22017}
22018
22019JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLProgressElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22020{
22021 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLProgressElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22022}
22023
22024static inline JSValue jsDOMWindow_HTMLQuoteElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22025{
22026 auto& vm = JSC::getVM(&lexicalGlobalObject);
22027 auto throwScope = DECLARE_THROW_SCOPE(vm);
22028 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22029 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22030 if (!shouldAllowAccess)
22031 return jsUndefined();
22032 return JSHTMLQuoteElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22033}
22034
22035JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLQuoteElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22036{
22037 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLQuoteElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22038}
22039
22040static inline JSValue jsDOMWindow_HTMLScriptElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22041{
22042 auto& vm = JSC::getVM(&lexicalGlobalObject);
22043 auto throwScope = DECLARE_THROW_SCOPE(vm);
22044 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22045 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22046 if (!shouldAllowAccess)
22047 return jsUndefined();
22048 return JSHTMLScriptElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22049}
22050
22051JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLScriptElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22052{
22053 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLScriptElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22054}
22055
22056static inline JSValue jsDOMWindow_HTMLSelectElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22057{
22058 auto& vm = JSC::getVM(&lexicalGlobalObject);
22059 auto throwScope = DECLARE_THROW_SCOPE(vm);
22060 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22061 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22062 if (!shouldAllowAccess)
22063 return jsUndefined();
22064 return JSHTMLSelectElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22065}
22066
22067JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLSelectElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22068{
22069 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLSelectElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22070}
22071
22072static inline JSValue jsDOMWindow_HTMLSlotElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22073{
22074 auto& vm = JSC::getVM(&lexicalGlobalObject);
22075 auto throwScope = DECLARE_THROW_SCOPE(vm);
22076 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22077 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22078 if (!shouldAllowAccess)
22079 return jsUndefined();
22080 return JSHTMLSlotElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22081}
22082
22083JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLSlotElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22084{
22085 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLSlotElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22086}
22087
22088static inline JSValue jsDOMWindow_HTMLSourceElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22089{
22090 auto& vm = JSC::getVM(&lexicalGlobalObject);
22091 auto throwScope = DECLARE_THROW_SCOPE(vm);
22092 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22093 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22094 if (!shouldAllowAccess)
22095 return jsUndefined();
22096 return JSHTMLSourceElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22097}
22098
22099JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLSourceElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22100{
22101 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLSourceElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22102}
22103
22104static inline JSValue jsDOMWindow_HTMLSpanElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22105{
22106 auto& vm = JSC::getVM(&lexicalGlobalObject);
22107 auto throwScope = DECLARE_THROW_SCOPE(vm);
22108 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22109 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22110 if (!shouldAllowAccess)
22111 return jsUndefined();
22112 return JSHTMLSpanElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22113}
22114
22115JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLSpanElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22116{
22117 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLSpanElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22118}
22119
22120static inline JSValue jsDOMWindow_HTMLStyleElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22121{
22122 auto& vm = JSC::getVM(&lexicalGlobalObject);
22123 auto throwScope = DECLARE_THROW_SCOPE(vm);
22124 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22125 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22126 if (!shouldAllowAccess)
22127 return jsUndefined();
22128 return JSHTMLStyleElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22129}
22130
22131JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLStyleElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22132{
22133 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLStyleElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22134}
22135
22136static inline JSValue jsDOMWindow_HTMLTableCaptionElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22137{
22138 auto& vm = JSC::getVM(&lexicalGlobalObject);
22139 auto throwScope = DECLARE_THROW_SCOPE(vm);
22140 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22141 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22142 if (!shouldAllowAccess)
22143 return jsUndefined();
22144 return JSHTMLTableCaptionElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22145}
22146
22147JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLTableCaptionElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22148{
22149 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLTableCaptionElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22150}
22151
22152static inline JSValue jsDOMWindow_HTMLTableCellElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22153{
22154 auto& vm = JSC::getVM(&lexicalGlobalObject);
22155 auto throwScope = DECLARE_THROW_SCOPE(vm);
22156 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22157 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22158 if (!shouldAllowAccess)
22159 return jsUndefined();
22160 return JSHTMLTableCellElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22161}
22162
22163JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLTableCellElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22164{
22165 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLTableCellElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22166}
22167
22168static inline JSValue jsDOMWindow_HTMLTableColElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22169{
22170 auto& vm = JSC::getVM(&lexicalGlobalObject);
22171 auto throwScope = DECLARE_THROW_SCOPE(vm);
22172 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22173 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22174 if (!shouldAllowAccess)
22175 return jsUndefined();
22176 return JSHTMLTableColElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22177}
22178
22179JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLTableColElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22180{
22181 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLTableColElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22182}
22183
22184static inline JSValue jsDOMWindow_HTMLTableElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22185{
22186 auto& vm = JSC::getVM(&lexicalGlobalObject);
22187 auto throwScope = DECLARE_THROW_SCOPE(vm);
22188 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22189 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22190 if (!shouldAllowAccess)
22191 return jsUndefined();
22192 return JSHTMLTableElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22193}
22194
22195JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLTableElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22196{
22197 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLTableElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22198}
22199
22200static inline JSValue jsDOMWindow_HTMLTableRowElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22201{
22202 auto& vm = JSC::getVM(&lexicalGlobalObject);
22203 auto throwScope = DECLARE_THROW_SCOPE(vm);
22204 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22205 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22206 if (!shouldAllowAccess)
22207 return jsUndefined();
22208 return JSHTMLTableRowElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22209}
22210
22211JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLTableRowElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22212{
22213 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLTableRowElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22214}
22215
22216static inline JSValue jsDOMWindow_HTMLTableSectionElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22217{
22218 auto& vm = JSC::getVM(&lexicalGlobalObject);
22219 auto throwScope = DECLARE_THROW_SCOPE(vm);
22220 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22221 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22222 if (!shouldAllowAccess)
22223 return jsUndefined();
22224 return JSHTMLTableSectionElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22225}
22226
22227JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLTableSectionElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22228{
22229 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLTableSectionElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22230}
22231
22232static inline JSValue jsDOMWindow_HTMLTemplateElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22233{
22234 auto& vm = JSC::getVM(&lexicalGlobalObject);
22235 auto throwScope = DECLARE_THROW_SCOPE(vm);
22236 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22237 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22238 if (!shouldAllowAccess)
22239 return jsUndefined();
22240 return JSHTMLTemplateElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22241}
22242
22243JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLTemplateElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22244{
22245 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLTemplateElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22246}
22247
22248static inline JSValue jsDOMWindow_HTMLTextAreaElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22249{
22250 auto& vm = JSC::getVM(&lexicalGlobalObject);
22251 auto throwScope = DECLARE_THROW_SCOPE(vm);
22252 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22253 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22254 if (!shouldAllowAccess)
22255 return jsUndefined();
22256 return JSHTMLTextAreaElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22257}
22258
22259JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLTextAreaElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22260{
22261 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLTextAreaElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22262}
22263
22264static inline JSValue jsDOMWindow_HTMLTimeElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22265{
22266 auto& vm = JSC::getVM(&lexicalGlobalObject);
22267 auto throwScope = DECLARE_THROW_SCOPE(vm);
22268 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22269 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22270 if (!shouldAllowAccess)
22271 return jsUndefined();
22272 return JSHTMLTimeElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22273}
22274
22275JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLTimeElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22276{
22277 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLTimeElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22278}
22279
22280static inline JSValue jsDOMWindow_HTMLTitleElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22281{
22282 auto& vm = JSC::getVM(&lexicalGlobalObject);
22283 auto throwScope = DECLARE_THROW_SCOPE(vm);
22284 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22285 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22286 if (!shouldAllowAccess)
22287 return jsUndefined();
22288 return JSHTMLTitleElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22289}
22290
22291JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLTitleElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22292{
22293 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLTitleElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22294}
22295
22296#if ENABLE(VIDEO)
22297static inline JSValue jsDOMWindow_HTMLTrackElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22298{
22299 auto& vm = JSC::getVM(&lexicalGlobalObject);
22300 auto throwScope = DECLARE_THROW_SCOPE(vm);
22301 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22302 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22303 if (!shouldAllowAccess)
22304 return jsUndefined();
22305 return JSHTMLTrackElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22306}
22307
22308JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLTrackElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22309{
22310 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLTrackElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22311}
22312
22313#endif
22314
22315static inline JSValue jsDOMWindow_HTMLUListElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22316{
22317 auto& vm = JSC::getVM(&lexicalGlobalObject);
22318 auto throwScope = DECLARE_THROW_SCOPE(vm);
22319 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22320 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22321 if (!shouldAllowAccess)
22322 return jsUndefined();
22323 return JSHTMLUListElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22324}
22325
22326JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLUListElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22327{
22328 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLUListElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22329}
22330
22331static inline JSValue jsDOMWindow_HTMLUnknownElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22332{
22333 auto& vm = JSC::getVM(&lexicalGlobalObject);
22334 auto throwScope = DECLARE_THROW_SCOPE(vm);
22335 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22336 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22337 if (!shouldAllowAccess)
22338 return jsUndefined();
22339 return JSHTMLUnknownElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22340}
22341
22342JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLUnknownElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22343{
22344 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLUnknownElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22345}
22346
22347#if ENABLE(VIDEO)
22348static inline JSValue jsDOMWindow_HTMLVideoElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22349{
22350 auto& vm = JSC::getVM(&lexicalGlobalObject);
22351 auto throwScope = DECLARE_THROW_SCOPE(vm);
22352 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22353 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22354 if (!shouldAllowAccess)
22355 return jsUndefined();
22356 return JSHTMLVideoElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22357}
22358
22359JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HTMLVideoElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22360{
22361 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HTMLVideoElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22362}
22363
22364#endif
22365
22366static inline JSValue jsDOMWindow_ImageBitmapConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22367{
22368 auto& vm = JSC::getVM(&lexicalGlobalObject);
22369 auto throwScope = DECLARE_THROW_SCOPE(vm);
22370 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22371 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22372 if (!shouldAllowAccess)
22373 return jsUndefined();
22374 return JSImageBitmap::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22375}
22376
22377JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ImageBitmapConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22378{
22379 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ImageBitmapConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22380}
22381
22382static inline JSValue jsDOMWindow_ImageDataConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22383{
22384 auto& vm = JSC::getVM(&lexicalGlobalObject);
22385 auto throwScope = DECLARE_THROW_SCOPE(vm);
22386 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22387 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22388 if (!shouldAllowAccess)
22389 return jsUndefined();
22390 return JSImageData::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22391}
22392
22393JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ImageDataConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22394{
22395 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ImageDataConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22396}
22397
22398#if ENABLE(VIDEO)
22399static inline JSValue jsDOMWindow_MediaControllerConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22400{
22401 auto& vm = JSC::getVM(&lexicalGlobalObject);
22402 auto throwScope = DECLARE_THROW_SCOPE(vm);
22403 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22404 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22405 if (!shouldAllowAccess)
22406 return jsUndefined();
22407 return JSMediaController::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22408}
22409
22410JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MediaControllerConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22411{
22412 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MediaControllerConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22413}
22414
22415#endif
22416
22417#if ENABLE(ENCRYPTED_MEDIA)
22418static inline JSValue jsDOMWindow_MediaEncryptedEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22419{
22420 auto& vm = JSC::getVM(&lexicalGlobalObject);
22421 auto throwScope = DECLARE_THROW_SCOPE(vm);
22422 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22423 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22424 if (!shouldAllowAccess)
22425 return jsUndefined();
22426 return JSMediaEncryptedEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22427}
22428
22429JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MediaEncryptedEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22430{
22431 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MediaEncryptedEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22432}
22433
22434#endif
22435
22436#if ENABLE(VIDEO)
22437static inline JSValue jsDOMWindow_MediaErrorConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22438{
22439 auto& vm = JSC::getVM(&lexicalGlobalObject);
22440 auto throwScope = DECLARE_THROW_SCOPE(vm);
22441 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22442 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22443 if (!shouldAllowAccess)
22444 return jsUndefined();
22445 return JSMediaError::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22446}
22447
22448JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MediaErrorConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22449{
22450 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MediaErrorConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22451}
22452
22453#endif
22454
22455#if ENABLE(OFFSCREEN_CANVAS)
22456static inline JSValue jsDOMWindow_OffscreenCanvasConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22457{
22458 auto& vm = JSC::getVM(&lexicalGlobalObject);
22459 auto throwScope = DECLARE_THROW_SCOPE(vm);
22460 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22461 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22462 if (!shouldAllowAccess)
22463 return jsUndefined();
22464 return JSOffscreenCanvas::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22465}
22466
22467JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_OffscreenCanvasConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22468{
22469 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_OffscreenCanvasConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22470}
22471
22472#endif
22473
22474static inline JSValue jsDOMWindow_RadioNodeListConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22475{
22476 auto& vm = JSC::getVM(&lexicalGlobalObject);
22477 auto throwScope = DECLARE_THROW_SCOPE(vm);
22478 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22479 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22480 if (!shouldAllowAccess)
22481 return jsUndefined();
22482 return JSRadioNodeList::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22483}
22484
22485JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_RadioNodeListConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22486{
22487 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_RadioNodeListConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22488}
22489
22490static inline JSValue jsDOMWindow_TextMetricsConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22491{
22492 auto& vm = JSC::getVM(&lexicalGlobalObject);
22493 auto throwScope = DECLARE_THROW_SCOPE(vm);
22494 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22495 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22496 if (!shouldAllowAccess)
22497 return jsUndefined();
22498 return JSTextMetrics::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22499}
22500
22501JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_TextMetricsConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22502{
22503 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_TextMetricsConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22504}
22505
22506#if ENABLE(VIDEO)
22507static inline JSValue jsDOMWindow_TimeRangesConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22508{
22509 auto& vm = JSC::getVM(&lexicalGlobalObject);
22510 auto throwScope = DECLARE_THROW_SCOPE(vm);
22511 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22512 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22513 if (!shouldAllowAccess)
22514 return jsUndefined();
22515 return JSTimeRanges::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22516}
22517
22518JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_TimeRangesConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22519{
22520 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_TimeRangesConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22521}
22522
22523#endif
22524
22525static inline JSValue jsDOMWindow_URLSearchParamsConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22526{
22527 auto& vm = JSC::getVM(&lexicalGlobalObject);
22528 auto throwScope = DECLARE_THROW_SCOPE(vm);
22529 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22530 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22531 if (!shouldAllowAccess)
22532 return jsUndefined();
22533 return JSURLSearchParams::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22534}
22535
22536JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_URLSearchParamsConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22537{
22538 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_URLSearchParamsConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22539}
22540
22541static inline JSValue jsDOMWindow_ValidityStateConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22542{
22543 auto& vm = JSC::getVM(&lexicalGlobalObject);
22544 auto throwScope = DECLARE_THROW_SCOPE(vm);
22545 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22546 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22547 if (!shouldAllowAccess)
22548 return jsUndefined();
22549 return JSValidityState::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22550}
22551
22552JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ValidityStateConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22553{
22554 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ValidityStateConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22555}
22556
22557#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
22558static inline JSValue jsDOMWindow_WebKitMediaKeyErrorConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22559{
22560 auto& vm = JSC::getVM(&lexicalGlobalObject);
22561 auto throwScope = DECLARE_THROW_SCOPE(vm);
22562 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22563 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22564 if (!shouldAllowAccess)
22565 return jsUndefined();
22566 return JSWebKitMediaKeyError::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22567}
22568
22569JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WebKitMediaKeyErrorConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22570{
22571 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WebKitMediaKeyErrorConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22572}
22573
22574#endif
22575
22576static inline JSValue jsDOMWindow_CanvasGradientConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22577{
22578 auto& vm = JSC::getVM(&lexicalGlobalObject);
22579 auto throwScope = DECLARE_THROW_SCOPE(vm);
22580 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22581 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22582 if (!shouldAllowAccess)
22583 return jsUndefined();
22584 return JSCanvasGradient::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22585}
22586
22587JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CanvasGradientConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22588{
22589 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CanvasGradientConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22590}
22591
22592static inline JSValue jsDOMWindow_CanvasPatternConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22593{
22594 auto& vm = JSC::getVM(&lexicalGlobalObject);
22595 auto throwScope = DECLARE_THROW_SCOPE(vm);
22596 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22597 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22598 if (!shouldAllowAccess)
22599 return jsUndefined();
22600 return JSCanvasPattern::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22601}
22602
22603JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CanvasPatternConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22604{
22605 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CanvasPatternConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22606}
22607
22608static inline JSValue jsDOMWindow_CanvasRenderingContext2DConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22609{
22610 auto& vm = JSC::getVM(&lexicalGlobalObject);
22611 auto throwScope = DECLARE_THROW_SCOPE(vm);
22612 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22613 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22614 if (!shouldAllowAccess)
22615 return jsUndefined();
22616 return JSCanvasRenderingContext2D::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22617}
22618
22619JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CanvasRenderingContext2DConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22620{
22621 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CanvasRenderingContext2DConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22622}
22623
22624static inline JSValue jsDOMWindow_ImageBitmapRenderingContextConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22625{
22626 auto& vm = JSC::getVM(&lexicalGlobalObject);
22627 auto throwScope = DECLARE_THROW_SCOPE(vm);
22628 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22629 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22630 if (!shouldAllowAccess)
22631 return jsUndefined();
22632 return JSImageBitmapRenderingContext::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22633}
22634
22635JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ImageBitmapRenderingContextConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22636{
22637 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ImageBitmapRenderingContextConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22638}
22639
22640#if ENABLE(OFFSCREEN_CANVAS)
22641static inline JSValue jsDOMWindow_OffscreenCanvasRenderingContext2DConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22642{
22643 auto& vm = JSC::getVM(&lexicalGlobalObject);
22644 auto throwScope = DECLARE_THROW_SCOPE(vm);
22645 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22646 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22647 if (!shouldAllowAccess)
22648 return jsUndefined();
22649 return JSOffscreenCanvasRenderingContext2D::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22650}
22651
22652JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_OffscreenCanvasRenderingContext2DConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22653{
22654 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_OffscreenCanvasRenderingContext2DConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22655}
22656
22657#endif
22658
22659static inline JSValue jsDOMWindow_Path2DConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22660{
22661 auto& vm = JSC::getVM(&lexicalGlobalObject);
22662 auto throwScope = DECLARE_THROW_SCOPE(vm);
22663 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22664 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22665 if (!shouldAllowAccess)
22666 return jsUndefined();
22667 return JSPath2D::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22668}
22669
22670JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_Path2DConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22671{
22672 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_Path2DConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22673}
22674
22675#if ENABLE(WEBGL2)
22676static inline JSValue jsDOMWindow_WebGL2RenderingContextConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22677{
22678 auto& vm = JSC::getVM(&lexicalGlobalObject);
22679 auto throwScope = DECLARE_THROW_SCOPE(vm);
22680 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22681 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22682 if (!shouldAllowAccess)
22683 return jsUndefined();
22684 return JSWebGL2RenderingContext::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22685}
22686
22687JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WebGL2RenderingContextConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22688{
22689 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WebGL2RenderingContextConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22690}
22691
22692#endif
22693
22694#if ENABLE(WEBGL)
22695static inline JSValue jsDOMWindow_WebGLActiveInfoConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22696{
22697 auto& vm = JSC::getVM(&lexicalGlobalObject);
22698 auto throwScope = DECLARE_THROW_SCOPE(vm);
22699 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22700 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22701 if (!shouldAllowAccess)
22702 return jsUndefined();
22703 return JSWebGLActiveInfo::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22704}
22705
22706JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WebGLActiveInfoConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22707{
22708 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WebGLActiveInfoConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22709}
22710
22711#endif
22712
22713#if ENABLE(WEBGL)
22714static inline JSValue jsDOMWindow_WebGLBufferConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22715{
22716 auto& vm = JSC::getVM(&lexicalGlobalObject);
22717 auto throwScope = DECLARE_THROW_SCOPE(vm);
22718 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22719 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22720 if (!shouldAllowAccess)
22721 return jsUndefined();
22722 return JSWebGLBuffer::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22723}
22724
22725JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WebGLBufferConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22726{
22727 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WebGLBufferConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22728}
22729
22730#endif
22731
22732#if ENABLE(WEBGL)
22733static inline JSValue jsDOMWindow_WebGLContextEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22734{
22735 auto& vm = JSC::getVM(&lexicalGlobalObject);
22736 auto throwScope = DECLARE_THROW_SCOPE(vm);
22737 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22738 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22739 if (!shouldAllowAccess)
22740 return jsUndefined();
22741 return JSWebGLContextEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22742}
22743
22744JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WebGLContextEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22745{
22746 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WebGLContextEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22747}
22748
22749#endif
22750
22751#if ENABLE(WEBGL)
22752static inline JSValue jsDOMWindow_WebGLFramebufferConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22753{
22754 auto& vm = JSC::getVM(&lexicalGlobalObject);
22755 auto throwScope = DECLARE_THROW_SCOPE(vm);
22756 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22757 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22758 if (!shouldAllowAccess)
22759 return jsUndefined();
22760 return JSWebGLFramebuffer::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22761}
22762
22763JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WebGLFramebufferConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22764{
22765 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WebGLFramebufferConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22766}
22767
22768#endif
22769
22770#if ENABLE(WEBGL)
22771static inline JSValue jsDOMWindow_WebGLProgramConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22772{
22773 auto& vm = JSC::getVM(&lexicalGlobalObject);
22774 auto throwScope = DECLARE_THROW_SCOPE(vm);
22775 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22776 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22777 if (!shouldAllowAccess)
22778 return jsUndefined();
22779 return JSWebGLProgram::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22780}
22781
22782JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WebGLProgramConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22783{
22784 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WebGLProgramConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22785}
22786
22787#endif
22788
22789#if ENABLE(WEBGL)
22790static inline JSValue jsDOMWindow_WebGLQueryConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22791{
22792 auto& vm = JSC::getVM(&lexicalGlobalObject);
22793 auto throwScope = DECLARE_THROW_SCOPE(vm);
22794 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22795 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22796 if (!shouldAllowAccess)
22797 return jsUndefined();
22798 return JSWebGLQuery::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22799}
22800
22801JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WebGLQueryConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22802{
22803 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WebGLQueryConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22804}
22805
22806#endif
22807
22808#if ENABLE(WEBGL)
22809static inline JSValue jsDOMWindow_WebGLRenderbufferConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22810{
22811 auto& vm = JSC::getVM(&lexicalGlobalObject);
22812 auto throwScope = DECLARE_THROW_SCOPE(vm);
22813 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22814 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22815 if (!shouldAllowAccess)
22816 return jsUndefined();
22817 return JSWebGLRenderbuffer::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22818}
22819
22820JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WebGLRenderbufferConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22821{
22822 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WebGLRenderbufferConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22823}
22824
22825#endif
22826
22827#if ENABLE(WEBGL)
22828static inline JSValue jsDOMWindow_WebGLRenderingContextConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22829{
22830 auto& vm = JSC::getVM(&lexicalGlobalObject);
22831 auto throwScope = DECLARE_THROW_SCOPE(vm);
22832 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22833 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22834 if (!shouldAllowAccess)
22835 return jsUndefined();
22836 return JSWebGLRenderingContext::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22837}
22838
22839JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WebGLRenderingContextConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22840{
22841 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WebGLRenderingContextConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22842}
22843
22844#endif
22845
22846#if ENABLE(WEBGL)
22847static inline JSValue jsDOMWindow_WebGLSamplerConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22848{
22849 auto& vm = JSC::getVM(&lexicalGlobalObject);
22850 auto throwScope = DECLARE_THROW_SCOPE(vm);
22851 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22852 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22853 if (!shouldAllowAccess)
22854 return jsUndefined();
22855 return JSWebGLSampler::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22856}
22857
22858JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WebGLSamplerConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22859{
22860 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WebGLSamplerConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22861}
22862
22863#endif
22864
22865#if ENABLE(WEBGL)
22866static inline JSValue jsDOMWindow_WebGLShaderConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22867{
22868 auto& vm = JSC::getVM(&lexicalGlobalObject);
22869 auto throwScope = DECLARE_THROW_SCOPE(vm);
22870 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22871 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22872 if (!shouldAllowAccess)
22873 return jsUndefined();
22874 return JSWebGLShader::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22875}
22876
22877JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WebGLShaderConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22878{
22879 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WebGLShaderConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22880}
22881
22882#endif
22883
22884#if ENABLE(WEBGL)
22885static inline JSValue jsDOMWindow_WebGLShaderPrecisionFormatConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22886{
22887 auto& vm = JSC::getVM(&lexicalGlobalObject);
22888 auto throwScope = DECLARE_THROW_SCOPE(vm);
22889 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22890 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22891 if (!shouldAllowAccess)
22892 return jsUndefined();
22893 return JSWebGLShaderPrecisionFormat::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22894}
22895
22896JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WebGLShaderPrecisionFormatConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22897{
22898 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WebGLShaderPrecisionFormatConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22899}
22900
22901#endif
22902
22903#if ENABLE(WEBGL)
22904static inline JSValue jsDOMWindow_WebGLSyncConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22905{
22906 auto& vm = JSC::getVM(&lexicalGlobalObject);
22907 auto throwScope = DECLARE_THROW_SCOPE(vm);
22908 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22909 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22910 if (!shouldAllowAccess)
22911 return jsUndefined();
22912 return JSWebGLSync::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22913}
22914
22915JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WebGLSyncConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22916{
22917 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WebGLSyncConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22918}
22919
22920#endif
22921
22922#if ENABLE(WEBGL)
22923static inline JSValue jsDOMWindow_WebGLTextureConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22924{
22925 auto& vm = JSC::getVM(&lexicalGlobalObject);
22926 auto throwScope = DECLARE_THROW_SCOPE(vm);
22927 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22928 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22929 if (!shouldAllowAccess)
22930 return jsUndefined();
22931 return JSWebGLTexture::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22932}
22933
22934JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WebGLTextureConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22935{
22936 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WebGLTextureConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22937}
22938
22939#endif
22940
22941#if ENABLE(WEBGL2)
22942static inline JSValue jsDOMWindow_WebGLTransformFeedbackConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22943{
22944 auto& vm = JSC::getVM(&lexicalGlobalObject);
22945 auto throwScope = DECLARE_THROW_SCOPE(vm);
22946 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22947 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22948 if (!shouldAllowAccess)
22949 return jsUndefined();
22950 return JSWebGLTransformFeedback::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22951}
22952
22953JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WebGLTransformFeedbackConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22954{
22955 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WebGLTransformFeedbackConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22956}
22957
22958#endif
22959
22960#if ENABLE(WEBGL)
22961static inline JSValue jsDOMWindow_WebGLUniformLocationConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22962{
22963 auto& vm = JSC::getVM(&lexicalGlobalObject);
22964 auto throwScope = DECLARE_THROW_SCOPE(vm);
22965 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22966 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22967 if (!shouldAllowAccess)
22968 return jsUndefined();
22969 return JSWebGLUniformLocation::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22970}
22971
22972JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WebGLUniformLocationConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22973{
22974 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WebGLUniformLocationConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22975}
22976
22977#endif
22978
22979#if ENABLE(WEBGL2)
22980static inline JSValue jsDOMWindow_WebGLVertexArrayObjectConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
22981{
22982 auto& vm = JSC::getVM(&lexicalGlobalObject);
22983 auto throwScope = DECLARE_THROW_SCOPE(vm);
22984 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
22985 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
22986 if (!shouldAllowAccess)
22987 return jsUndefined();
22988 return JSWebGLVertexArrayObject::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
22989}
22990
22991JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WebGLVertexArrayObjectConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
22992{
22993 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WebGLVertexArrayObjectConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
22994}
22995
22996#endif
22997
22998#if ENABLE(VIDEO)
22999static inline JSValue jsDOMWindow_AudioTrackConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23000{
23001 auto& vm = JSC::getVM(&lexicalGlobalObject);
23002 auto throwScope = DECLARE_THROW_SCOPE(vm);
23003 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23004 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23005 if (!shouldAllowAccess)
23006 return jsUndefined();
23007 return JSAudioTrack::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23008}
23009
23010JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_AudioTrackConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23011{
23012 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_AudioTrackConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23013}
23014
23015#endif
23016
23017#if ENABLE(VIDEO)
23018static inline JSValue jsDOMWindow_AudioTrackListConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23019{
23020 auto& vm = JSC::getVM(&lexicalGlobalObject);
23021 auto throwScope = DECLARE_THROW_SCOPE(vm);
23022 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23023 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23024 if (!shouldAllowAccess)
23025 return jsUndefined();
23026 return JSAudioTrackList::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23027}
23028
23029JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_AudioTrackListConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23030{
23031 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_AudioTrackListConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23032}
23033
23034#endif
23035
23036#if ENABLE(VIDEO)
23037static inline JSValue jsDOMWindow_DataCueConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23038{
23039 auto& vm = JSC::getVM(&lexicalGlobalObject);
23040 auto throwScope = DECLARE_THROW_SCOPE(vm);
23041 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23042 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23043 if (!shouldAllowAccess)
23044 return jsUndefined();
23045 return JSDataCue::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23046}
23047
23048JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_DataCueConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23049{
23050 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_DataCueConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23051}
23052
23053#endif
23054
23055#if ENABLE(VIDEO)
23056static inline JSValue jsDOMWindow_TextTrackConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23057{
23058 auto& vm = JSC::getVM(&lexicalGlobalObject);
23059 auto throwScope = DECLARE_THROW_SCOPE(vm);
23060 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23061 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23062 if (!shouldAllowAccess)
23063 return jsUndefined();
23064 return JSTextTrack::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23065}
23066
23067JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_TextTrackConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23068{
23069 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_TextTrackConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23070}
23071
23072#endif
23073
23074#if ENABLE(VIDEO)
23075static inline JSValue jsDOMWindow_TextTrackCueConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23076{
23077 auto& vm = JSC::getVM(&lexicalGlobalObject);
23078 auto throwScope = DECLARE_THROW_SCOPE(vm);
23079 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23080 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23081 if (!shouldAllowAccess)
23082 return jsUndefined();
23083 return JSTextTrackCue::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23084}
23085
23086JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_TextTrackCueConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23087{
23088 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_TextTrackCueConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23089}
23090
23091#endif
23092
23093#if ENABLE(VIDEO)
23094static inline JSValue jsDOMWindow_TextTrackCueListConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23095{
23096 auto& vm = JSC::getVM(&lexicalGlobalObject);
23097 auto throwScope = DECLARE_THROW_SCOPE(vm);
23098 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23099 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23100 if (!shouldAllowAccess)
23101 return jsUndefined();
23102 return JSTextTrackCueList::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23103}
23104
23105JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_TextTrackCueListConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23106{
23107 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_TextTrackCueListConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23108}
23109
23110#endif
23111
23112#if ENABLE(VIDEO)
23113static inline JSValue jsDOMWindow_TextTrackListConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23114{
23115 auto& vm = JSC::getVM(&lexicalGlobalObject);
23116 auto throwScope = DECLARE_THROW_SCOPE(vm);
23117 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23118 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23119 if (!shouldAllowAccess)
23120 return jsUndefined();
23121 return JSTextTrackList::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23122}
23123
23124JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_TextTrackListConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23125{
23126 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_TextTrackListConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23127}
23128
23129#endif
23130
23131#if ENABLE(VIDEO)
23132static inline JSValue jsDOMWindow_TrackEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23133{
23134 auto& vm = JSC::getVM(&lexicalGlobalObject);
23135 auto throwScope = DECLARE_THROW_SCOPE(vm);
23136 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23137 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23138 if (!shouldAllowAccess)
23139 return jsUndefined();
23140 return JSTrackEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23141}
23142
23143JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_TrackEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23144{
23145 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_TrackEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23146}
23147
23148#endif
23149
23150#if ENABLE(VIDEO)
23151static inline JSValue jsDOMWindow_VTTCueConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23152{
23153 auto& vm = JSC::getVM(&lexicalGlobalObject);
23154 auto throwScope = DECLARE_THROW_SCOPE(vm);
23155 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23156 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23157 if (!shouldAllowAccess)
23158 return jsUndefined();
23159 return JSVTTCue::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23160}
23161
23162JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_VTTCueConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23163{
23164 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_VTTCueConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23165}
23166
23167#endif
23168
23169#if ENABLE(VIDEO)
23170static inline JSValue jsDOMWindow_VTTRegionConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23171{
23172 auto& vm = JSC::getVM(&lexicalGlobalObject);
23173 auto throwScope = DECLARE_THROW_SCOPE(vm);
23174 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23175 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23176 if (!shouldAllowAccess)
23177 return jsUndefined();
23178 return JSVTTRegion::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23179}
23180
23181JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_VTTRegionConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23182{
23183 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_VTTRegionConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23184}
23185
23186#endif
23187
23188#if ENABLE(VIDEO)
23189static inline JSValue jsDOMWindow_VideoTrackConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23190{
23191 auto& vm = JSC::getVM(&lexicalGlobalObject);
23192 auto throwScope = DECLARE_THROW_SCOPE(vm);
23193 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23194 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23195 if (!shouldAllowAccess)
23196 return jsUndefined();
23197 return JSVideoTrack::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23198}
23199
23200JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_VideoTrackConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23201{
23202 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_VideoTrackConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23203}
23204
23205#endif
23206
23207#if ENABLE(VIDEO)
23208static inline JSValue jsDOMWindow_VideoTrackListConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23209{
23210 auto& vm = JSC::getVM(&lexicalGlobalObject);
23211 auto throwScope = DECLARE_THROW_SCOPE(vm);
23212 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23213 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23214 if (!shouldAllowAccess)
23215 return jsUndefined();
23216 return JSVideoTrackList::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23217}
23218
23219JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_VideoTrackListConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23220{
23221 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_VideoTrackListConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23222}
23223
23224#endif
23225
23226static inline JSValue jsDOMWindow_ApplicationCacheConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23227{
23228 auto& vm = JSC::getVM(&lexicalGlobalObject);
23229 auto throwScope = DECLARE_THROW_SCOPE(vm);
23230 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23231 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23232 if (!shouldAllowAccess)
23233 return jsUndefined();
23234 return JSDOMApplicationCache::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23235}
23236
23237JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ApplicationCacheConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23238{
23239 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ApplicationCacheConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23240}
23241
23242#if ENABLE(MATHML)
23243static inline JSValue jsDOMWindow_MathMLElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23244{
23245 auto& vm = JSC::getVM(&lexicalGlobalObject);
23246 auto throwScope = DECLARE_THROW_SCOPE(vm);
23247 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23248 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23249 if (!shouldAllowAccess)
23250 return jsUndefined();
23251 return JSMathMLElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23252}
23253
23254JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MathMLElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23255{
23256 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MathMLElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23257}
23258
23259#endif
23260
23261#if ENABLE(MATHML)
23262static inline JSValue jsDOMWindow_MathMLMathElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23263{
23264 auto& vm = JSC::getVM(&lexicalGlobalObject);
23265 auto throwScope = DECLARE_THROW_SCOPE(vm);
23266 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23267 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23268 if (!shouldAllowAccess)
23269 return jsUndefined();
23270 return JSMathMLMathElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23271}
23272
23273JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MathMLMathElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23274{
23275 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MathMLMathElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23276}
23277
23278#endif
23279
23280static inline JSValue jsDOMWindow_BarPropConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23281{
23282 auto& vm = JSC::getVM(&lexicalGlobalObject);
23283 auto throwScope = DECLARE_THROW_SCOPE(vm);
23284 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23285 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23286 if (!shouldAllowAccess)
23287 return jsUndefined();
23288 return JSBarProp::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23289}
23290
23291JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_BarPropConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23292{
23293 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_BarPropConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23294}
23295
23296static inline JSValue jsDOMWindow_CryptoConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23297{
23298 auto& vm = JSC::getVM(&lexicalGlobalObject);
23299 auto throwScope = DECLARE_THROW_SCOPE(vm);
23300 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23301 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23302 if (!shouldAllowAccess)
23303 return jsUndefined();
23304 return JSCrypto::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23305}
23306
23307JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_CryptoConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23308{
23309 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_CryptoConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23310}
23311
23312static inline JSValue jsDOMWindow_SelectionConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23313{
23314 auto& vm = JSC::getVM(&lexicalGlobalObject);
23315 auto throwScope = DECLARE_THROW_SCOPE(vm);
23316 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23317 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23318 if (!shouldAllowAccess)
23319 return jsUndefined();
23320 return JSDOMSelection::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23321}
23322
23323JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SelectionConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23324{
23325 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SelectionConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23326}
23327
23328static inline JSValue jsDOMWindow_WindowConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23329{
23330 auto& vm = JSC::getVM(&lexicalGlobalObject);
23331 auto throwScope = DECLARE_THROW_SCOPE(vm);
23332 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23333 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23334 if (!shouldAllowAccess)
23335 return jsUndefined();
23336 return JSDOMWindow::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23337}
23338
23339JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WindowConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23340{
23341 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WindowConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23342}
23343
23344static inline JSValue jsDOMWindow_EventSourceConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23345{
23346 auto& vm = JSC::getVM(&lexicalGlobalObject);
23347 auto throwScope = DECLARE_THROW_SCOPE(vm);
23348 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23349 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23350 if (!shouldAllowAccess)
23351 return jsUndefined();
23352 return JSEventSource::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23353}
23354
23355JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_EventSourceConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23356{
23357 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_EventSourceConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23358}
23359
23360static inline JSValue jsDOMWindow_HistoryConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23361{
23362 auto& vm = JSC::getVM(&lexicalGlobalObject);
23363 auto throwScope = DECLARE_THROW_SCOPE(vm);
23364 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23365 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23366 if (!shouldAllowAccess)
23367 return jsUndefined();
23368 return JSHistory::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23369}
23370
23371JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_HistoryConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23372{
23373 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_HistoryConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23374}
23375
23376#if ENABLE(INTERSECTION_OBSERVER)
23377static inline JSValue jsDOMWindow_IntersectionObserverConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23378{
23379 auto& vm = JSC::getVM(&lexicalGlobalObject);
23380 auto throwScope = DECLARE_THROW_SCOPE(vm);
23381 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23382 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23383 if (!shouldAllowAccess)
23384 return jsUndefined();
23385 return JSIntersectionObserver::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23386}
23387
23388JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_IntersectionObserverConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23389{
23390 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_IntersectionObserverConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23391}
23392
23393#endif
23394
23395#if ENABLE(INTERSECTION_OBSERVER)
23396static inline JSValue jsDOMWindow_IntersectionObserverEntryConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23397{
23398 auto& vm = JSC::getVM(&lexicalGlobalObject);
23399 auto throwScope = DECLARE_THROW_SCOPE(vm);
23400 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23401 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23402 if (!shouldAllowAccess)
23403 return jsUndefined();
23404 return JSIntersectionObserverEntry::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23405}
23406
23407JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_IntersectionObserverEntryConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23408{
23409 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_IntersectionObserverEntryConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23410}
23411
23412#endif
23413
23414static inline JSValue jsDOMWindow_LocationConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23415{
23416 auto& vm = JSC::getVM(&lexicalGlobalObject);
23417 auto throwScope = DECLARE_THROW_SCOPE(vm);
23418 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23419 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23420 if (!shouldAllowAccess)
23421 return jsUndefined();
23422 return JSLocation::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23423}
23424
23425JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_LocationConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23426{
23427 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_LocationConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23428}
23429
23430static inline JSValue jsDOMWindow_NavigatorConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23431{
23432 auto& vm = JSC::getVM(&lexicalGlobalObject);
23433 auto throwScope = DECLARE_THROW_SCOPE(vm);
23434 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23435 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23436 if (!shouldAllowAccess)
23437 return jsUndefined();
23438 return JSNavigator::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23439}
23440
23441JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_NavigatorConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23442{
23443 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_NavigatorConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23444}
23445
23446static inline JSValue jsDOMWindow_PerformanceConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23447{
23448 auto& vm = JSC::getVM(&lexicalGlobalObject);
23449 auto throwScope = DECLARE_THROW_SCOPE(vm);
23450 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23451 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23452 if (!shouldAllowAccess)
23453 return jsUndefined();
23454 return JSPerformance::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23455}
23456
23457JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_PerformanceConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23458{
23459 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_PerformanceConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23460}
23461
23462static inline JSValue jsDOMWindow_PerformanceEntryConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23463{
23464 auto& vm = JSC::getVM(&lexicalGlobalObject);
23465 auto throwScope = DECLARE_THROW_SCOPE(vm);
23466 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23467 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23468 if (!shouldAllowAccess)
23469 return jsUndefined();
23470 return JSPerformanceEntry::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23471}
23472
23473JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_PerformanceEntryConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23474{
23475 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_PerformanceEntryConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23476}
23477
23478static inline JSValue jsDOMWindow_PerformanceMarkConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23479{
23480 auto& vm = JSC::getVM(&lexicalGlobalObject);
23481 auto throwScope = DECLARE_THROW_SCOPE(vm);
23482 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23483 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23484 if (!shouldAllowAccess)
23485 return jsUndefined();
23486 return JSPerformanceMark::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23487}
23488
23489JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_PerformanceMarkConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23490{
23491 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_PerformanceMarkConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23492}
23493
23494static inline JSValue jsDOMWindow_PerformanceMeasureConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23495{
23496 auto& vm = JSC::getVM(&lexicalGlobalObject);
23497 auto throwScope = DECLARE_THROW_SCOPE(vm);
23498 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23499 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23500 if (!shouldAllowAccess)
23501 return jsUndefined();
23502 return JSPerformanceMeasure::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23503}
23504
23505JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_PerformanceMeasureConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23506{
23507 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_PerformanceMeasureConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23508}
23509
23510static inline JSValue jsDOMWindow_PerformanceNavigationConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23511{
23512 auto& vm = JSC::getVM(&lexicalGlobalObject);
23513 auto throwScope = DECLARE_THROW_SCOPE(vm);
23514 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23515 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23516 if (!shouldAllowAccess)
23517 return jsUndefined();
23518 return JSPerformanceNavigation::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23519}
23520
23521JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_PerformanceNavigationConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23522{
23523 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_PerformanceNavigationConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23524}
23525
23526static inline JSValue jsDOMWindow_PerformanceNavigationTimingConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23527{
23528 auto& vm = JSC::getVM(&lexicalGlobalObject);
23529 auto throwScope = DECLARE_THROW_SCOPE(vm);
23530 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23531 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23532 if (!shouldAllowAccess)
23533 return jsUndefined();
23534 return JSPerformanceNavigationTiming::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23535}
23536
23537JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_PerformanceNavigationTimingConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23538{
23539 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_PerformanceNavigationTimingConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23540}
23541
23542static inline JSValue jsDOMWindow_PerformanceObserverConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23543{
23544 auto& vm = JSC::getVM(&lexicalGlobalObject);
23545 auto throwScope = DECLARE_THROW_SCOPE(vm);
23546 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23547 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23548 if (!shouldAllowAccess)
23549 return jsUndefined();
23550 return JSPerformanceObserver::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23551}
23552
23553JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_PerformanceObserverConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23554{
23555 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_PerformanceObserverConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23556}
23557
23558static inline JSValue jsDOMWindow_PerformanceObserverEntryListConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23559{
23560 auto& vm = JSC::getVM(&lexicalGlobalObject);
23561 auto throwScope = DECLARE_THROW_SCOPE(vm);
23562 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23563 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23564 if (!shouldAllowAccess)
23565 return jsUndefined();
23566 return JSPerformanceObserverEntryList::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23567}
23568
23569JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_PerformanceObserverEntryListConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23570{
23571 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_PerformanceObserverEntryListConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23572}
23573
23574static inline JSValue jsDOMWindow_PerformancePaintTimingConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23575{
23576 auto& vm = JSC::getVM(&lexicalGlobalObject);
23577 auto throwScope = DECLARE_THROW_SCOPE(vm);
23578 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23579 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23580 if (!shouldAllowAccess)
23581 return jsUndefined();
23582 return JSPerformancePaintTiming::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23583}
23584
23585JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_PerformancePaintTimingConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23586{
23587 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_PerformancePaintTimingConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23588}
23589
23590static inline JSValue jsDOMWindow_PerformanceResourceTimingConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23591{
23592 auto& vm = JSC::getVM(&lexicalGlobalObject);
23593 auto throwScope = DECLARE_THROW_SCOPE(vm);
23594 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23595 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23596 if (!shouldAllowAccess)
23597 return jsUndefined();
23598 return JSPerformanceResourceTiming::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23599}
23600
23601JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_PerformanceResourceTimingConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23602{
23603 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_PerformanceResourceTimingConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23604}
23605
23606static inline JSValue jsDOMWindow_PerformanceServerTimingConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23607{
23608 auto& vm = JSC::getVM(&lexicalGlobalObject);
23609 auto throwScope = DECLARE_THROW_SCOPE(vm);
23610 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23611 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23612 if (!shouldAllowAccess)
23613 return jsUndefined();
23614 return JSPerformanceServerTiming::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23615}
23616
23617JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_PerformanceServerTimingConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23618{
23619 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_PerformanceServerTimingConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23620}
23621
23622static inline JSValue jsDOMWindow_PerformanceTimingConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23623{
23624 auto& vm = JSC::getVM(&lexicalGlobalObject);
23625 auto throwScope = DECLARE_THROW_SCOPE(vm);
23626 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23627 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23628 if (!shouldAllowAccess)
23629 return jsUndefined();
23630 return JSPerformanceTiming::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23631}
23632
23633JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_PerformanceTimingConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23634{
23635 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_PerformanceTimingConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23636}
23637
23638#if ENABLE(RESIZE_OBSERVER)
23639static inline JSValue jsDOMWindow_ResizeObserverConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23640{
23641 auto& vm = JSC::getVM(&lexicalGlobalObject);
23642 auto throwScope = DECLARE_THROW_SCOPE(vm);
23643 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23644 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23645 if (!shouldAllowAccess)
23646 return jsUndefined();
23647 return JSResizeObserver::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23648}
23649
23650JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ResizeObserverConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23651{
23652 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ResizeObserverConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23653}
23654
23655#endif
23656
23657#if ENABLE(RESIZE_OBSERVER)
23658static inline JSValue jsDOMWindow_ResizeObserverEntryConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23659{
23660 auto& vm = JSC::getVM(&lexicalGlobalObject);
23661 auto throwScope = DECLARE_THROW_SCOPE(vm);
23662 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23663 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23664 if (!shouldAllowAccess)
23665 return jsUndefined();
23666 return JSResizeObserverEntry::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23667}
23668
23669JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ResizeObserverEntryConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23670{
23671 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ResizeObserverEntryConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23672}
23673
23674#endif
23675
23676static inline JSValue jsDOMWindow_ScreenConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23677{
23678 auto& vm = JSC::getVM(&lexicalGlobalObject);
23679 auto throwScope = DECLARE_THROW_SCOPE(vm);
23680 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23681 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23682 if (!shouldAllowAccess)
23683 return jsUndefined();
23684 return JSScreen::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23685}
23686
23687JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ScreenConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23688{
23689 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ScreenConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23690}
23691
23692static inline JSValue jsDOMWindow_UndoItemConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23693{
23694 auto& vm = JSC::getVM(&lexicalGlobalObject);
23695 auto throwScope = DECLARE_THROW_SCOPE(vm);
23696 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23697 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23698 if (!shouldAllowAccess)
23699 return jsUndefined();
23700 return JSUndoItem::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23701}
23702
23703JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_UndoItemConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23704{
23705 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_UndoItemConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23706}
23707
23708static inline JSValue jsDOMWindow_UndoManagerConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23709{
23710 auto& vm = JSC::getVM(&lexicalGlobalObject);
23711 auto throwScope = DECLARE_THROW_SCOPE(vm);
23712 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23713 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23714 if (!shouldAllowAccess)
23715 return jsUndefined();
23716 return JSUndoManager::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23717}
23718
23719JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_UndoManagerConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23720{
23721 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_UndoManagerConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23722}
23723
23724#if ENABLE(USER_MESSAGE_HANDLERS)
23725static inline JSValue jsDOMWindow_UserMessageHandlerConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23726{
23727 auto& vm = JSC::getVM(&lexicalGlobalObject);
23728 auto throwScope = DECLARE_THROW_SCOPE(vm);
23729 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23730 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23731 if (!shouldAllowAccess)
23732 return jsUndefined();
23733 return JSUserMessageHandler::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23734}
23735
23736JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_UserMessageHandlerConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23737{
23738 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_UserMessageHandlerConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23739}
23740
23741#endif
23742
23743#if ENABLE(USER_MESSAGE_HANDLERS)
23744static inline JSValue jsDOMWindow_UserMessageHandlersNamespaceConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23745{
23746 auto& vm = JSC::getVM(&lexicalGlobalObject);
23747 auto throwScope = DECLARE_THROW_SCOPE(vm);
23748 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23749 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23750 if (!shouldAllowAccess)
23751 return jsUndefined();
23752 return JSUserMessageHandlersNamespace::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23753}
23754
23755JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_UserMessageHandlersNamespaceConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23756{
23757 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_UserMessageHandlersNamespaceConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23758}
23759
23760#endif
23761
23762static inline JSValue jsDOMWindow_VisualViewportConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23763{
23764 auto& vm = JSC::getVM(&lexicalGlobalObject);
23765 auto throwScope = DECLARE_THROW_SCOPE(vm);
23766 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23767 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23768 if (!shouldAllowAccess)
23769 return jsUndefined();
23770 return JSVisualViewport::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23771}
23772
23773JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_VisualViewportConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23774{
23775 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_VisualViewportConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23776}
23777
23778#if ENABLE(USER_MESSAGE_HANDLERS)
23779static inline JSValue jsDOMWindow_WebKitNamespaceConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23780{
23781 auto& vm = JSC::getVM(&lexicalGlobalObject);
23782 auto throwScope = DECLARE_THROW_SCOPE(vm);
23783 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23784 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23785 if (!shouldAllowAccess)
23786 return jsUndefined();
23787 return JSWebKitNamespace::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23788}
23789
23790JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WebKitNamespaceConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23791{
23792 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WebKitNamespaceConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23793}
23794
23795#endif
23796
23797static inline JSValue jsDOMWindow_WebKitPointConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23798{
23799 auto& vm = JSC::getVM(&lexicalGlobalObject);
23800 auto throwScope = DECLARE_THROW_SCOPE(vm);
23801 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23802 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23803 if (!shouldAllowAccess)
23804 return jsUndefined();
23805 return JSWebKitPoint::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23806}
23807
23808JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WebKitPointConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23809{
23810 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WebKitPointConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23811}
23812
23813static inline JSValue jsDOMWindow_MimeTypeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23814{
23815 auto& vm = JSC::getVM(&lexicalGlobalObject);
23816 auto throwScope = DECLARE_THROW_SCOPE(vm);
23817 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23818 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23819 if (!shouldAllowAccess)
23820 return jsUndefined();
23821 return JSDOMMimeType::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23822}
23823
23824JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MimeTypeConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23825{
23826 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MimeTypeConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23827}
23828
23829static inline JSValue jsDOMWindow_MimeTypeArrayConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23830{
23831 auto& vm = JSC::getVM(&lexicalGlobalObject);
23832 auto throwScope = DECLARE_THROW_SCOPE(vm);
23833 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23834 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23835 if (!shouldAllowAccess)
23836 return jsUndefined();
23837 return JSDOMMimeTypeArray::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23838}
23839
23840JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_MimeTypeArrayConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23841{
23842 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_MimeTypeArrayConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23843}
23844
23845static inline JSValue jsDOMWindow_PluginConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23846{
23847 auto& vm = JSC::getVM(&lexicalGlobalObject);
23848 auto throwScope = DECLARE_THROW_SCOPE(vm);
23849 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23850 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23851 if (!shouldAllowAccess)
23852 return jsUndefined();
23853 return JSDOMPlugin::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23854}
23855
23856JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_PluginConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23857{
23858 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_PluginConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23859}
23860
23861static inline JSValue jsDOMWindow_PluginArrayConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23862{
23863 auto& vm = JSC::getVM(&lexicalGlobalObject);
23864 auto throwScope = DECLARE_THROW_SCOPE(vm);
23865 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23866 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23867 if (!shouldAllowAccess)
23868 return jsUndefined();
23869 return JSDOMPluginArray::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23870}
23871
23872JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_PluginArrayConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23873{
23874 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_PluginArrayConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23875}
23876
23877static inline JSValue jsDOMWindow_StorageConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23878{
23879 auto& vm = JSC::getVM(&lexicalGlobalObject);
23880 auto throwScope = DECLARE_THROW_SCOPE(vm);
23881 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23882 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23883 if (!shouldAllowAccess)
23884 return jsUndefined();
23885 return JSStorage::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23886}
23887
23888JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_StorageConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23889{
23890 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_StorageConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23891}
23892
23893static inline JSValue jsDOMWindow_StorageEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23894{
23895 auto& vm = JSC::getVM(&lexicalGlobalObject);
23896 auto throwScope = DECLARE_THROW_SCOPE(vm);
23897 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23898 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23899 if (!shouldAllowAccess)
23900 return jsUndefined();
23901 return JSStorageEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23902}
23903
23904JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_StorageEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23905{
23906 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_StorageEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23907}
23908
23909static inline JSValue jsDOMWindow_SVGAElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23910{
23911 auto& vm = JSC::getVM(&lexicalGlobalObject);
23912 auto throwScope = DECLARE_THROW_SCOPE(vm);
23913 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23914 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23915 if (!shouldAllowAccess)
23916 return jsUndefined();
23917 return JSSVGAElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23918}
23919
23920JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGAElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23921{
23922 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGAElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23923}
23924
23925static inline JSValue jsDOMWindow_SVGAltGlyphDefElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23926{
23927 auto& vm = JSC::getVM(&lexicalGlobalObject);
23928 auto throwScope = DECLARE_THROW_SCOPE(vm);
23929 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23930 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23931 if (!shouldAllowAccess)
23932 return jsUndefined();
23933 return JSSVGAltGlyphDefElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23934}
23935
23936JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGAltGlyphDefElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23937{
23938 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGAltGlyphDefElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23939}
23940
23941static inline JSValue jsDOMWindow_SVGAltGlyphElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23942{
23943 auto& vm = JSC::getVM(&lexicalGlobalObject);
23944 auto throwScope = DECLARE_THROW_SCOPE(vm);
23945 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23946 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23947 if (!shouldAllowAccess)
23948 return jsUndefined();
23949 return JSSVGAltGlyphElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23950}
23951
23952JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGAltGlyphElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23953{
23954 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGAltGlyphElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23955}
23956
23957static inline JSValue jsDOMWindow_SVGAltGlyphItemElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23958{
23959 auto& vm = JSC::getVM(&lexicalGlobalObject);
23960 auto throwScope = DECLARE_THROW_SCOPE(vm);
23961 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23962 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23963 if (!shouldAllowAccess)
23964 return jsUndefined();
23965 return JSSVGAltGlyphItemElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23966}
23967
23968JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGAltGlyphItemElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23969{
23970 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGAltGlyphItemElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23971}
23972
23973static inline JSValue jsDOMWindow_SVGAngleConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23974{
23975 auto& vm = JSC::getVM(&lexicalGlobalObject);
23976 auto throwScope = DECLARE_THROW_SCOPE(vm);
23977 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23978 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23979 if (!shouldAllowAccess)
23980 return jsUndefined();
23981 return JSSVGAngle::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23982}
23983
23984JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGAngleConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
23985{
23986 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGAngleConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
23987}
23988
23989static inline JSValue jsDOMWindow_SVGAnimateColorElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
23990{
23991 auto& vm = JSC::getVM(&lexicalGlobalObject);
23992 auto throwScope = DECLARE_THROW_SCOPE(vm);
23993 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
23994 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
23995 if (!shouldAllowAccess)
23996 return jsUndefined();
23997 return JSSVGAnimateColorElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
23998}
23999
24000JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGAnimateColorElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24001{
24002 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGAnimateColorElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24003}
24004
24005static inline JSValue jsDOMWindow_SVGAnimateElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24006{
24007 auto& vm = JSC::getVM(&lexicalGlobalObject);
24008 auto throwScope = DECLARE_THROW_SCOPE(vm);
24009 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24010 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24011 if (!shouldAllowAccess)
24012 return jsUndefined();
24013 return JSSVGAnimateElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24014}
24015
24016JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGAnimateElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24017{
24018 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGAnimateElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24019}
24020
24021static inline JSValue jsDOMWindow_SVGAnimateMotionElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24022{
24023 auto& vm = JSC::getVM(&lexicalGlobalObject);
24024 auto throwScope = DECLARE_THROW_SCOPE(vm);
24025 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24026 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24027 if (!shouldAllowAccess)
24028 return jsUndefined();
24029 return JSSVGAnimateMotionElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24030}
24031
24032JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGAnimateMotionElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24033{
24034 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGAnimateMotionElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24035}
24036
24037static inline JSValue jsDOMWindow_SVGAnimateTransformElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24038{
24039 auto& vm = JSC::getVM(&lexicalGlobalObject);
24040 auto throwScope = DECLARE_THROW_SCOPE(vm);
24041 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24042 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24043 if (!shouldAllowAccess)
24044 return jsUndefined();
24045 return JSSVGAnimateTransformElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24046}
24047
24048JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGAnimateTransformElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24049{
24050 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGAnimateTransformElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24051}
24052
24053static inline JSValue jsDOMWindow_SVGAnimatedAngleConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24054{
24055 auto& vm = JSC::getVM(&lexicalGlobalObject);
24056 auto throwScope = DECLARE_THROW_SCOPE(vm);
24057 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24058 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24059 if (!shouldAllowAccess)
24060 return jsUndefined();
24061 return JSSVGAnimatedAngle::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24062}
24063
24064JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGAnimatedAngleConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24065{
24066 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGAnimatedAngleConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24067}
24068
24069static inline JSValue jsDOMWindow_SVGAnimatedBooleanConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24070{
24071 auto& vm = JSC::getVM(&lexicalGlobalObject);
24072 auto throwScope = DECLARE_THROW_SCOPE(vm);
24073 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24074 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24075 if (!shouldAllowAccess)
24076 return jsUndefined();
24077 return JSSVGAnimatedBoolean::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24078}
24079
24080JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGAnimatedBooleanConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24081{
24082 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGAnimatedBooleanConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24083}
24084
24085static inline JSValue jsDOMWindow_SVGAnimatedEnumerationConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24086{
24087 auto& vm = JSC::getVM(&lexicalGlobalObject);
24088 auto throwScope = DECLARE_THROW_SCOPE(vm);
24089 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24090 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24091 if (!shouldAllowAccess)
24092 return jsUndefined();
24093 return JSSVGAnimatedEnumeration::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24094}
24095
24096JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGAnimatedEnumerationConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24097{
24098 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGAnimatedEnumerationConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24099}
24100
24101static inline JSValue jsDOMWindow_SVGAnimatedIntegerConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24102{
24103 auto& vm = JSC::getVM(&lexicalGlobalObject);
24104 auto throwScope = DECLARE_THROW_SCOPE(vm);
24105 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24106 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24107 if (!shouldAllowAccess)
24108 return jsUndefined();
24109 return JSSVGAnimatedInteger::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24110}
24111
24112JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGAnimatedIntegerConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24113{
24114 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGAnimatedIntegerConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24115}
24116
24117static inline JSValue jsDOMWindow_SVGAnimatedLengthConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24118{
24119 auto& vm = JSC::getVM(&lexicalGlobalObject);
24120 auto throwScope = DECLARE_THROW_SCOPE(vm);
24121 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24122 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24123 if (!shouldAllowAccess)
24124 return jsUndefined();
24125 return JSSVGAnimatedLength::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24126}
24127
24128JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGAnimatedLengthConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24129{
24130 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGAnimatedLengthConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24131}
24132
24133static inline JSValue jsDOMWindow_SVGAnimatedLengthListConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24134{
24135 auto& vm = JSC::getVM(&lexicalGlobalObject);
24136 auto throwScope = DECLARE_THROW_SCOPE(vm);
24137 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24138 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24139 if (!shouldAllowAccess)
24140 return jsUndefined();
24141 return JSSVGAnimatedLengthList::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24142}
24143
24144JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGAnimatedLengthListConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24145{
24146 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGAnimatedLengthListConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24147}
24148
24149static inline JSValue jsDOMWindow_SVGAnimatedNumberConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24150{
24151 auto& vm = JSC::getVM(&lexicalGlobalObject);
24152 auto throwScope = DECLARE_THROW_SCOPE(vm);
24153 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24154 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24155 if (!shouldAllowAccess)
24156 return jsUndefined();
24157 return JSSVGAnimatedNumber::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24158}
24159
24160JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGAnimatedNumberConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24161{
24162 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGAnimatedNumberConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24163}
24164
24165static inline JSValue jsDOMWindow_SVGAnimatedNumberListConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24166{
24167 auto& vm = JSC::getVM(&lexicalGlobalObject);
24168 auto throwScope = DECLARE_THROW_SCOPE(vm);
24169 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24170 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24171 if (!shouldAllowAccess)
24172 return jsUndefined();
24173 return JSSVGAnimatedNumberList::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24174}
24175
24176JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGAnimatedNumberListConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24177{
24178 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGAnimatedNumberListConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24179}
24180
24181static inline JSValue jsDOMWindow_SVGAnimatedPreserveAspectRatioConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24182{
24183 auto& vm = JSC::getVM(&lexicalGlobalObject);
24184 auto throwScope = DECLARE_THROW_SCOPE(vm);
24185 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24186 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24187 if (!shouldAllowAccess)
24188 return jsUndefined();
24189 return JSSVGAnimatedPreserveAspectRatio::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24190}
24191
24192JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGAnimatedPreserveAspectRatioConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24193{
24194 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGAnimatedPreserveAspectRatioConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24195}
24196
24197static inline JSValue jsDOMWindow_SVGAnimatedRectConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24198{
24199 auto& vm = JSC::getVM(&lexicalGlobalObject);
24200 auto throwScope = DECLARE_THROW_SCOPE(vm);
24201 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24202 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24203 if (!shouldAllowAccess)
24204 return jsUndefined();
24205 return JSSVGAnimatedRect::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24206}
24207
24208JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGAnimatedRectConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24209{
24210 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGAnimatedRectConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24211}
24212
24213static inline JSValue jsDOMWindow_SVGAnimatedStringConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24214{
24215 auto& vm = JSC::getVM(&lexicalGlobalObject);
24216 auto throwScope = DECLARE_THROW_SCOPE(vm);
24217 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24218 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24219 if (!shouldAllowAccess)
24220 return jsUndefined();
24221 return JSSVGAnimatedString::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24222}
24223
24224JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGAnimatedStringConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24225{
24226 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGAnimatedStringConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24227}
24228
24229static inline JSValue jsDOMWindow_SVGAnimatedTransformListConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24230{
24231 auto& vm = JSC::getVM(&lexicalGlobalObject);
24232 auto throwScope = DECLARE_THROW_SCOPE(vm);
24233 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24234 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24235 if (!shouldAllowAccess)
24236 return jsUndefined();
24237 return JSSVGAnimatedTransformList::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24238}
24239
24240JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGAnimatedTransformListConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24241{
24242 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGAnimatedTransformListConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24243}
24244
24245static inline JSValue jsDOMWindow_SVGAnimationElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24246{
24247 auto& vm = JSC::getVM(&lexicalGlobalObject);
24248 auto throwScope = DECLARE_THROW_SCOPE(vm);
24249 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24250 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24251 if (!shouldAllowAccess)
24252 return jsUndefined();
24253 return JSSVGAnimationElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24254}
24255
24256JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGAnimationElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24257{
24258 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGAnimationElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24259}
24260
24261static inline JSValue jsDOMWindow_SVGCircleElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24262{
24263 auto& vm = JSC::getVM(&lexicalGlobalObject);
24264 auto throwScope = DECLARE_THROW_SCOPE(vm);
24265 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24266 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24267 if (!shouldAllowAccess)
24268 return jsUndefined();
24269 return JSSVGCircleElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24270}
24271
24272JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGCircleElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24273{
24274 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGCircleElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24275}
24276
24277static inline JSValue jsDOMWindow_SVGClipPathElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24278{
24279 auto& vm = JSC::getVM(&lexicalGlobalObject);
24280 auto throwScope = DECLARE_THROW_SCOPE(vm);
24281 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24282 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24283 if (!shouldAllowAccess)
24284 return jsUndefined();
24285 return JSSVGClipPathElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24286}
24287
24288JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGClipPathElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24289{
24290 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGClipPathElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24291}
24292
24293static inline JSValue jsDOMWindow_SVGComponentTransferFunctionElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24294{
24295 auto& vm = JSC::getVM(&lexicalGlobalObject);
24296 auto throwScope = DECLARE_THROW_SCOPE(vm);
24297 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24298 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24299 if (!shouldAllowAccess)
24300 return jsUndefined();
24301 return JSSVGComponentTransferFunctionElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24302}
24303
24304JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGComponentTransferFunctionElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24305{
24306 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGComponentTransferFunctionElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24307}
24308
24309static inline JSValue jsDOMWindow_SVGCursorElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24310{
24311 auto& vm = JSC::getVM(&lexicalGlobalObject);
24312 auto throwScope = DECLARE_THROW_SCOPE(vm);
24313 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24314 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24315 if (!shouldAllowAccess)
24316 return jsUndefined();
24317 return JSSVGCursorElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24318}
24319
24320JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGCursorElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24321{
24322 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGCursorElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24323}
24324
24325static inline JSValue jsDOMWindow_SVGDefsElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24326{
24327 auto& vm = JSC::getVM(&lexicalGlobalObject);
24328 auto throwScope = DECLARE_THROW_SCOPE(vm);
24329 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24330 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24331 if (!shouldAllowAccess)
24332 return jsUndefined();
24333 return JSSVGDefsElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24334}
24335
24336JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGDefsElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24337{
24338 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGDefsElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24339}
24340
24341static inline JSValue jsDOMWindow_SVGDescElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24342{
24343 auto& vm = JSC::getVM(&lexicalGlobalObject);
24344 auto throwScope = DECLARE_THROW_SCOPE(vm);
24345 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24346 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24347 if (!shouldAllowAccess)
24348 return jsUndefined();
24349 return JSSVGDescElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24350}
24351
24352JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGDescElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24353{
24354 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGDescElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24355}
24356
24357static inline JSValue jsDOMWindow_SVGElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24358{
24359 auto& vm = JSC::getVM(&lexicalGlobalObject);
24360 auto throwScope = DECLARE_THROW_SCOPE(vm);
24361 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24362 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24363 if (!shouldAllowAccess)
24364 return jsUndefined();
24365 return JSSVGElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24366}
24367
24368JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24369{
24370 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24371}
24372
24373static inline JSValue jsDOMWindow_SVGEllipseElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24374{
24375 auto& vm = JSC::getVM(&lexicalGlobalObject);
24376 auto throwScope = DECLARE_THROW_SCOPE(vm);
24377 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24378 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24379 if (!shouldAllowAccess)
24380 return jsUndefined();
24381 return JSSVGEllipseElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24382}
24383
24384JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGEllipseElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24385{
24386 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGEllipseElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24387}
24388
24389static inline JSValue jsDOMWindow_SVGFEBlendElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24390{
24391 auto& vm = JSC::getVM(&lexicalGlobalObject);
24392 auto throwScope = DECLARE_THROW_SCOPE(vm);
24393 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24394 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24395 if (!shouldAllowAccess)
24396 return jsUndefined();
24397 return JSSVGFEBlendElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24398}
24399
24400JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGFEBlendElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24401{
24402 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGFEBlendElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24403}
24404
24405static inline JSValue jsDOMWindow_SVGFEColorMatrixElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24406{
24407 auto& vm = JSC::getVM(&lexicalGlobalObject);
24408 auto throwScope = DECLARE_THROW_SCOPE(vm);
24409 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24410 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24411 if (!shouldAllowAccess)
24412 return jsUndefined();
24413 return JSSVGFEColorMatrixElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24414}
24415
24416JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGFEColorMatrixElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24417{
24418 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGFEColorMatrixElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24419}
24420
24421static inline JSValue jsDOMWindow_SVGFEComponentTransferElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24422{
24423 auto& vm = JSC::getVM(&lexicalGlobalObject);
24424 auto throwScope = DECLARE_THROW_SCOPE(vm);
24425 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24426 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24427 if (!shouldAllowAccess)
24428 return jsUndefined();
24429 return JSSVGFEComponentTransferElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24430}
24431
24432JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGFEComponentTransferElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24433{
24434 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGFEComponentTransferElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24435}
24436
24437static inline JSValue jsDOMWindow_SVGFECompositeElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24438{
24439 auto& vm = JSC::getVM(&lexicalGlobalObject);
24440 auto throwScope = DECLARE_THROW_SCOPE(vm);
24441 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24442 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24443 if (!shouldAllowAccess)
24444 return jsUndefined();
24445 return JSSVGFECompositeElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24446}
24447
24448JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGFECompositeElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24449{
24450 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGFECompositeElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24451}
24452
24453static inline JSValue jsDOMWindow_SVGFEConvolveMatrixElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24454{
24455 auto& vm = JSC::getVM(&lexicalGlobalObject);
24456 auto throwScope = DECLARE_THROW_SCOPE(vm);
24457 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24458 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24459 if (!shouldAllowAccess)
24460 return jsUndefined();
24461 return JSSVGFEConvolveMatrixElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24462}
24463
24464JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGFEConvolveMatrixElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24465{
24466 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGFEConvolveMatrixElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24467}
24468
24469static inline JSValue jsDOMWindow_SVGFEDiffuseLightingElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24470{
24471 auto& vm = JSC::getVM(&lexicalGlobalObject);
24472 auto throwScope = DECLARE_THROW_SCOPE(vm);
24473 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24474 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24475 if (!shouldAllowAccess)
24476 return jsUndefined();
24477 return JSSVGFEDiffuseLightingElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24478}
24479
24480JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGFEDiffuseLightingElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24481{
24482 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGFEDiffuseLightingElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24483}
24484
24485static inline JSValue jsDOMWindow_SVGFEDisplacementMapElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24486{
24487 auto& vm = JSC::getVM(&lexicalGlobalObject);
24488 auto throwScope = DECLARE_THROW_SCOPE(vm);
24489 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24490 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24491 if (!shouldAllowAccess)
24492 return jsUndefined();
24493 return JSSVGFEDisplacementMapElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24494}
24495
24496JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGFEDisplacementMapElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24497{
24498 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGFEDisplacementMapElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24499}
24500
24501static inline JSValue jsDOMWindow_SVGFEDistantLightElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24502{
24503 auto& vm = JSC::getVM(&lexicalGlobalObject);
24504 auto throwScope = DECLARE_THROW_SCOPE(vm);
24505 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24506 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24507 if (!shouldAllowAccess)
24508 return jsUndefined();
24509 return JSSVGFEDistantLightElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24510}
24511
24512JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGFEDistantLightElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24513{
24514 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGFEDistantLightElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24515}
24516
24517static inline JSValue jsDOMWindow_SVGFEDropShadowElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24518{
24519 auto& vm = JSC::getVM(&lexicalGlobalObject);
24520 auto throwScope = DECLARE_THROW_SCOPE(vm);
24521 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24522 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24523 if (!shouldAllowAccess)
24524 return jsUndefined();
24525 return JSSVGFEDropShadowElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24526}
24527
24528JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGFEDropShadowElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24529{
24530 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGFEDropShadowElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24531}
24532
24533static inline JSValue jsDOMWindow_SVGFEFloodElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24534{
24535 auto& vm = JSC::getVM(&lexicalGlobalObject);
24536 auto throwScope = DECLARE_THROW_SCOPE(vm);
24537 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24538 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24539 if (!shouldAllowAccess)
24540 return jsUndefined();
24541 return JSSVGFEFloodElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24542}
24543
24544JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGFEFloodElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24545{
24546 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGFEFloodElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24547}
24548
24549static inline JSValue jsDOMWindow_SVGFEFuncAElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24550{
24551 auto& vm = JSC::getVM(&lexicalGlobalObject);
24552 auto throwScope = DECLARE_THROW_SCOPE(vm);
24553 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24554 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24555 if (!shouldAllowAccess)
24556 return jsUndefined();
24557 return JSSVGFEFuncAElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24558}
24559
24560JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGFEFuncAElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24561{
24562 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGFEFuncAElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24563}
24564
24565static inline JSValue jsDOMWindow_SVGFEFuncBElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24566{
24567 auto& vm = JSC::getVM(&lexicalGlobalObject);
24568 auto throwScope = DECLARE_THROW_SCOPE(vm);
24569 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24570 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24571 if (!shouldAllowAccess)
24572 return jsUndefined();
24573 return JSSVGFEFuncBElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24574}
24575
24576JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGFEFuncBElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24577{
24578 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGFEFuncBElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24579}
24580
24581static inline JSValue jsDOMWindow_SVGFEFuncGElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24582{
24583 auto& vm = JSC::getVM(&lexicalGlobalObject);
24584 auto throwScope = DECLARE_THROW_SCOPE(vm);
24585 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24586 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24587 if (!shouldAllowAccess)
24588 return jsUndefined();
24589 return JSSVGFEFuncGElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24590}
24591
24592JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGFEFuncGElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24593{
24594 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGFEFuncGElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24595}
24596
24597static inline JSValue jsDOMWindow_SVGFEFuncRElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24598{
24599 auto& vm = JSC::getVM(&lexicalGlobalObject);
24600 auto throwScope = DECLARE_THROW_SCOPE(vm);
24601 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24602 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24603 if (!shouldAllowAccess)
24604 return jsUndefined();
24605 return JSSVGFEFuncRElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24606}
24607
24608JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGFEFuncRElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24609{
24610 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGFEFuncRElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24611}
24612
24613static inline JSValue jsDOMWindow_SVGFEGaussianBlurElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24614{
24615 auto& vm = JSC::getVM(&lexicalGlobalObject);
24616 auto throwScope = DECLARE_THROW_SCOPE(vm);
24617 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24618 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24619 if (!shouldAllowAccess)
24620 return jsUndefined();
24621 return JSSVGFEGaussianBlurElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24622}
24623
24624JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGFEGaussianBlurElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24625{
24626 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGFEGaussianBlurElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24627}
24628
24629static inline JSValue jsDOMWindow_SVGFEImageElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24630{
24631 auto& vm = JSC::getVM(&lexicalGlobalObject);
24632 auto throwScope = DECLARE_THROW_SCOPE(vm);
24633 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24634 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24635 if (!shouldAllowAccess)
24636 return jsUndefined();
24637 return JSSVGFEImageElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24638}
24639
24640JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGFEImageElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24641{
24642 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGFEImageElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24643}
24644
24645static inline JSValue jsDOMWindow_SVGFEMergeElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24646{
24647 auto& vm = JSC::getVM(&lexicalGlobalObject);
24648 auto throwScope = DECLARE_THROW_SCOPE(vm);
24649 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24650 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24651 if (!shouldAllowAccess)
24652 return jsUndefined();
24653 return JSSVGFEMergeElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24654}
24655
24656JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGFEMergeElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24657{
24658 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGFEMergeElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24659}
24660
24661static inline JSValue jsDOMWindow_SVGFEMergeNodeElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24662{
24663 auto& vm = JSC::getVM(&lexicalGlobalObject);
24664 auto throwScope = DECLARE_THROW_SCOPE(vm);
24665 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24666 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24667 if (!shouldAllowAccess)
24668 return jsUndefined();
24669 return JSSVGFEMergeNodeElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24670}
24671
24672JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGFEMergeNodeElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24673{
24674 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGFEMergeNodeElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24675}
24676
24677static inline JSValue jsDOMWindow_SVGFEMorphologyElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24678{
24679 auto& vm = JSC::getVM(&lexicalGlobalObject);
24680 auto throwScope = DECLARE_THROW_SCOPE(vm);
24681 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24682 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24683 if (!shouldAllowAccess)
24684 return jsUndefined();
24685 return JSSVGFEMorphologyElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24686}
24687
24688JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGFEMorphologyElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24689{
24690 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGFEMorphologyElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24691}
24692
24693static inline JSValue jsDOMWindow_SVGFEOffsetElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24694{
24695 auto& vm = JSC::getVM(&lexicalGlobalObject);
24696 auto throwScope = DECLARE_THROW_SCOPE(vm);
24697 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24698 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24699 if (!shouldAllowAccess)
24700 return jsUndefined();
24701 return JSSVGFEOffsetElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24702}
24703
24704JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGFEOffsetElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24705{
24706 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGFEOffsetElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24707}
24708
24709static inline JSValue jsDOMWindow_SVGFEPointLightElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24710{
24711 auto& vm = JSC::getVM(&lexicalGlobalObject);
24712 auto throwScope = DECLARE_THROW_SCOPE(vm);
24713 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24714 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24715 if (!shouldAllowAccess)
24716 return jsUndefined();
24717 return JSSVGFEPointLightElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24718}
24719
24720JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGFEPointLightElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24721{
24722 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGFEPointLightElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24723}
24724
24725static inline JSValue jsDOMWindow_SVGFESpecularLightingElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24726{
24727 auto& vm = JSC::getVM(&lexicalGlobalObject);
24728 auto throwScope = DECLARE_THROW_SCOPE(vm);
24729 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24730 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24731 if (!shouldAllowAccess)
24732 return jsUndefined();
24733 return JSSVGFESpecularLightingElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24734}
24735
24736JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGFESpecularLightingElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24737{
24738 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGFESpecularLightingElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24739}
24740
24741static inline JSValue jsDOMWindow_SVGFESpotLightElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24742{
24743 auto& vm = JSC::getVM(&lexicalGlobalObject);
24744 auto throwScope = DECLARE_THROW_SCOPE(vm);
24745 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24746 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24747 if (!shouldAllowAccess)
24748 return jsUndefined();
24749 return JSSVGFESpotLightElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24750}
24751
24752JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGFESpotLightElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24753{
24754 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGFESpotLightElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24755}
24756
24757static inline JSValue jsDOMWindow_SVGFETileElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24758{
24759 auto& vm = JSC::getVM(&lexicalGlobalObject);
24760 auto throwScope = DECLARE_THROW_SCOPE(vm);
24761 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24762 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24763 if (!shouldAllowAccess)
24764 return jsUndefined();
24765 return JSSVGFETileElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24766}
24767
24768JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGFETileElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24769{
24770 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGFETileElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24771}
24772
24773static inline JSValue jsDOMWindow_SVGFETurbulenceElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24774{
24775 auto& vm = JSC::getVM(&lexicalGlobalObject);
24776 auto throwScope = DECLARE_THROW_SCOPE(vm);
24777 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24778 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24779 if (!shouldAllowAccess)
24780 return jsUndefined();
24781 return JSSVGFETurbulenceElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24782}
24783
24784JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGFETurbulenceElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24785{
24786 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGFETurbulenceElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24787}
24788
24789static inline JSValue jsDOMWindow_SVGFilterElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24790{
24791 auto& vm = JSC::getVM(&lexicalGlobalObject);
24792 auto throwScope = DECLARE_THROW_SCOPE(vm);
24793 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24794 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24795 if (!shouldAllowAccess)
24796 return jsUndefined();
24797 return JSSVGFilterElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24798}
24799
24800JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGFilterElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24801{
24802 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGFilterElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24803}
24804
24805static inline JSValue jsDOMWindow_SVGFontElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24806{
24807 auto& vm = JSC::getVM(&lexicalGlobalObject);
24808 auto throwScope = DECLARE_THROW_SCOPE(vm);
24809 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24810 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24811 if (!shouldAllowAccess)
24812 return jsUndefined();
24813 return JSSVGFontElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24814}
24815
24816JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGFontElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24817{
24818 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGFontElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24819}
24820
24821static inline JSValue jsDOMWindow_SVGFontFaceElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24822{
24823 auto& vm = JSC::getVM(&lexicalGlobalObject);
24824 auto throwScope = DECLARE_THROW_SCOPE(vm);
24825 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24826 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24827 if (!shouldAllowAccess)
24828 return jsUndefined();
24829 return JSSVGFontFaceElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24830}
24831
24832JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGFontFaceElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24833{
24834 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGFontFaceElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24835}
24836
24837static inline JSValue jsDOMWindow_SVGFontFaceFormatElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24838{
24839 auto& vm = JSC::getVM(&lexicalGlobalObject);
24840 auto throwScope = DECLARE_THROW_SCOPE(vm);
24841 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24842 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24843 if (!shouldAllowAccess)
24844 return jsUndefined();
24845 return JSSVGFontFaceFormatElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24846}
24847
24848JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGFontFaceFormatElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24849{
24850 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGFontFaceFormatElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24851}
24852
24853static inline JSValue jsDOMWindow_SVGFontFaceNameElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24854{
24855 auto& vm = JSC::getVM(&lexicalGlobalObject);
24856 auto throwScope = DECLARE_THROW_SCOPE(vm);
24857 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24858 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24859 if (!shouldAllowAccess)
24860 return jsUndefined();
24861 return JSSVGFontFaceNameElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24862}
24863
24864JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGFontFaceNameElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24865{
24866 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGFontFaceNameElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24867}
24868
24869static inline JSValue jsDOMWindow_SVGFontFaceSrcElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24870{
24871 auto& vm = JSC::getVM(&lexicalGlobalObject);
24872 auto throwScope = DECLARE_THROW_SCOPE(vm);
24873 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24874 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24875 if (!shouldAllowAccess)
24876 return jsUndefined();
24877 return JSSVGFontFaceSrcElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24878}
24879
24880JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGFontFaceSrcElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24881{
24882 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGFontFaceSrcElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24883}
24884
24885static inline JSValue jsDOMWindow_SVGFontFaceUriElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24886{
24887 auto& vm = JSC::getVM(&lexicalGlobalObject);
24888 auto throwScope = DECLARE_THROW_SCOPE(vm);
24889 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24890 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24891 if (!shouldAllowAccess)
24892 return jsUndefined();
24893 return JSSVGFontFaceUriElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24894}
24895
24896JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGFontFaceUriElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24897{
24898 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGFontFaceUriElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24899}
24900
24901static inline JSValue jsDOMWindow_SVGForeignObjectElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24902{
24903 auto& vm = JSC::getVM(&lexicalGlobalObject);
24904 auto throwScope = DECLARE_THROW_SCOPE(vm);
24905 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24906 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24907 if (!shouldAllowAccess)
24908 return jsUndefined();
24909 return JSSVGForeignObjectElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24910}
24911
24912JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGForeignObjectElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24913{
24914 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGForeignObjectElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24915}
24916
24917static inline JSValue jsDOMWindow_SVGGElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24918{
24919 auto& vm = JSC::getVM(&lexicalGlobalObject);
24920 auto throwScope = DECLARE_THROW_SCOPE(vm);
24921 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24922 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24923 if (!shouldAllowAccess)
24924 return jsUndefined();
24925 return JSSVGGElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24926}
24927
24928JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGGElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24929{
24930 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGGElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24931}
24932
24933static inline JSValue jsDOMWindow_SVGGeometryElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24934{
24935 auto& vm = JSC::getVM(&lexicalGlobalObject);
24936 auto throwScope = DECLARE_THROW_SCOPE(vm);
24937 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24938 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24939 if (!shouldAllowAccess)
24940 return jsUndefined();
24941 return JSSVGGeometryElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24942}
24943
24944JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGGeometryElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24945{
24946 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGGeometryElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24947}
24948
24949static inline JSValue jsDOMWindow_SVGGlyphElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24950{
24951 auto& vm = JSC::getVM(&lexicalGlobalObject);
24952 auto throwScope = DECLARE_THROW_SCOPE(vm);
24953 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24954 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24955 if (!shouldAllowAccess)
24956 return jsUndefined();
24957 return JSSVGGlyphElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24958}
24959
24960JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGGlyphElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24961{
24962 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGGlyphElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24963}
24964
24965static inline JSValue jsDOMWindow_SVGGlyphRefElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24966{
24967 auto& vm = JSC::getVM(&lexicalGlobalObject);
24968 auto throwScope = DECLARE_THROW_SCOPE(vm);
24969 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24970 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24971 if (!shouldAllowAccess)
24972 return jsUndefined();
24973 return JSSVGGlyphRefElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24974}
24975
24976JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGGlyphRefElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24977{
24978 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGGlyphRefElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24979}
24980
24981static inline JSValue jsDOMWindow_SVGGradientElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24982{
24983 auto& vm = JSC::getVM(&lexicalGlobalObject);
24984 auto throwScope = DECLARE_THROW_SCOPE(vm);
24985 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
24986 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
24987 if (!shouldAllowAccess)
24988 return jsUndefined();
24989 return JSSVGGradientElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
24990}
24991
24992JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGGradientElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
24993{
24994 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGGradientElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
24995}
24996
24997static inline JSValue jsDOMWindow_SVGGraphicsElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
24998{
24999 auto& vm = JSC::getVM(&lexicalGlobalObject);
25000 auto throwScope = DECLARE_THROW_SCOPE(vm);
25001 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25002 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25003 if (!shouldAllowAccess)
25004 return jsUndefined();
25005 return JSSVGGraphicsElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25006}
25007
25008JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGGraphicsElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25009{
25010 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGGraphicsElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25011}
25012
25013static inline JSValue jsDOMWindow_SVGHKernElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25014{
25015 auto& vm = JSC::getVM(&lexicalGlobalObject);
25016 auto throwScope = DECLARE_THROW_SCOPE(vm);
25017 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25018 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25019 if (!shouldAllowAccess)
25020 return jsUndefined();
25021 return JSSVGHKernElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25022}
25023
25024JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGHKernElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25025{
25026 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGHKernElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25027}
25028
25029static inline JSValue jsDOMWindow_SVGImageElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25030{
25031 auto& vm = JSC::getVM(&lexicalGlobalObject);
25032 auto throwScope = DECLARE_THROW_SCOPE(vm);
25033 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25034 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25035 if (!shouldAllowAccess)
25036 return jsUndefined();
25037 return JSSVGImageElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25038}
25039
25040JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGImageElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25041{
25042 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGImageElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25043}
25044
25045static inline JSValue jsDOMWindow_SVGLengthConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25046{
25047 auto& vm = JSC::getVM(&lexicalGlobalObject);
25048 auto throwScope = DECLARE_THROW_SCOPE(vm);
25049 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25050 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25051 if (!shouldAllowAccess)
25052 return jsUndefined();
25053 return JSSVGLength::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25054}
25055
25056JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGLengthConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25057{
25058 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGLengthConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25059}
25060
25061static inline JSValue jsDOMWindow_SVGLengthListConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25062{
25063 auto& vm = JSC::getVM(&lexicalGlobalObject);
25064 auto throwScope = DECLARE_THROW_SCOPE(vm);
25065 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25066 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25067 if (!shouldAllowAccess)
25068 return jsUndefined();
25069 return JSSVGLengthList::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25070}
25071
25072JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGLengthListConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25073{
25074 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGLengthListConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25075}
25076
25077static inline JSValue jsDOMWindow_SVGLineElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25078{
25079 auto& vm = JSC::getVM(&lexicalGlobalObject);
25080 auto throwScope = DECLARE_THROW_SCOPE(vm);
25081 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25082 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25083 if (!shouldAllowAccess)
25084 return jsUndefined();
25085 return JSSVGLineElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25086}
25087
25088JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGLineElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25089{
25090 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGLineElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25091}
25092
25093static inline JSValue jsDOMWindow_SVGLinearGradientElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25094{
25095 auto& vm = JSC::getVM(&lexicalGlobalObject);
25096 auto throwScope = DECLARE_THROW_SCOPE(vm);
25097 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25098 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25099 if (!shouldAllowAccess)
25100 return jsUndefined();
25101 return JSSVGLinearGradientElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25102}
25103
25104JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGLinearGradientElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25105{
25106 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGLinearGradientElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25107}
25108
25109static inline JSValue jsDOMWindow_SVGMPathElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25110{
25111 auto& vm = JSC::getVM(&lexicalGlobalObject);
25112 auto throwScope = DECLARE_THROW_SCOPE(vm);
25113 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25114 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25115 if (!shouldAllowAccess)
25116 return jsUndefined();
25117 return JSSVGMPathElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25118}
25119
25120JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGMPathElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25121{
25122 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGMPathElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25123}
25124
25125static inline JSValue jsDOMWindow_SVGMarkerElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25126{
25127 auto& vm = JSC::getVM(&lexicalGlobalObject);
25128 auto throwScope = DECLARE_THROW_SCOPE(vm);
25129 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25130 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25131 if (!shouldAllowAccess)
25132 return jsUndefined();
25133 return JSSVGMarkerElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25134}
25135
25136JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGMarkerElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25137{
25138 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGMarkerElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25139}
25140
25141static inline JSValue jsDOMWindow_SVGMaskElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25142{
25143 auto& vm = JSC::getVM(&lexicalGlobalObject);
25144 auto throwScope = DECLARE_THROW_SCOPE(vm);
25145 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25146 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25147 if (!shouldAllowAccess)
25148 return jsUndefined();
25149 return JSSVGMaskElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25150}
25151
25152JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGMaskElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25153{
25154 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGMaskElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25155}
25156
25157static inline JSValue jsDOMWindow_SVGMatrixConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25158{
25159 auto& vm = JSC::getVM(&lexicalGlobalObject);
25160 auto throwScope = DECLARE_THROW_SCOPE(vm);
25161 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25162 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25163 if (!shouldAllowAccess)
25164 return jsUndefined();
25165 return JSSVGMatrix::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25166}
25167
25168JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGMatrixConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25169{
25170 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGMatrixConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25171}
25172
25173static inline JSValue jsDOMWindow_SVGMetadataElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25174{
25175 auto& vm = JSC::getVM(&lexicalGlobalObject);
25176 auto throwScope = DECLARE_THROW_SCOPE(vm);
25177 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25178 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25179 if (!shouldAllowAccess)
25180 return jsUndefined();
25181 return JSSVGMetadataElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25182}
25183
25184JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGMetadataElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25185{
25186 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGMetadataElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25187}
25188
25189static inline JSValue jsDOMWindow_SVGMissingGlyphElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25190{
25191 auto& vm = JSC::getVM(&lexicalGlobalObject);
25192 auto throwScope = DECLARE_THROW_SCOPE(vm);
25193 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25194 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25195 if (!shouldAllowAccess)
25196 return jsUndefined();
25197 return JSSVGMissingGlyphElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25198}
25199
25200JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGMissingGlyphElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25201{
25202 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGMissingGlyphElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25203}
25204
25205static inline JSValue jsDOMWindow_SVGNumberConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25206{
25207 auto& vm = JSC::getVM(&lexicalGlobalObject);
25208 auto throwScope = DECLARE_THROW_SCOPE(vm);
25209 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25210 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25211 if (!shouldAllowAccess)
25212 return jsUndefined();
25213 return JSSVGNumber::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25214}
25215
25216JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGNumberConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25217{
25218 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGNumberConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25219}
25220
25221static inline JSValue jsDOMWindow_SVGNumberListConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25222{
25223 auto& vm = JSC::getVM(&lexicalGlobalObject);
25224 auto throwScope = DECLARE_THROW_SCOPE(vm);
25225 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25226 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25227 if (!shouldAllowAccess)
25228 return jsUndefined();
25229 return JSSVGNumberList::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25230}
25231
25232JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGNumberListConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25233{
25234 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGNumberListConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25235}
25236
25237static inline JSValue jsDOMWindow_SVGPathElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25238{
25239 auto& vm = JSC::getVM(&lexicalGlobalObject);
25240 auto throwScope = DECLARE_THROW_SCOPE(vm);
25241 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25242 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25243 if (!shouldAllowAccess)
25244 return jsUndefined();
25245 return JSSVGPathElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25246}
25247
25248JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGPathElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25249{
25250 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGPathElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25251}
25252
25253static inline JSValue jsDOMWindow_SVGPathSegConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25254{
25255 auto& vm = JSC::getVM(&lexicalGlobalObject);
25256 auto throwScope = DECLARE_THROW_SCOPE(vm);
25257 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25258 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25259 if (!shouldAllowAccess)
25260 return jsUndefined();
25261 return JSSVGPathSeg::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25262}
25263
25264JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25265{
25266 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGPathSegConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25267}
25268
25269static inline JSValue jsDOMWindow_SVGPathSegArcAbsConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25270{
25271 auto& vm = JSC::getVM(&lexicalGlobalObject);
25272 auto throwScope = DECLARE_THROW_SCOPE(vm);
25273 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25274 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25275 if (!shouldAllowAccess)
25276 return jsUndefined();
25277 return JSSVGPathSegArcAbs::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25278}
25279
25280JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegArcAbsConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25281{
25282 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGPathSegArcAbsConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25283}
25284
25285static inline JSValue jsDOMWindow_SVGPathSegArcRelConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25286{
25287 auto& vm = JSC::getVM(&lexicalGlobalObject);
25288 auto throwScope = DECLARE_THROW_SCOPE(vm);
25289 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25290 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25291 if (!shouldAllowAccess)
25292 return jsUndefined();
25293 return JSSVGPathSegArcRel::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25294}
25295
25296JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegArcRelConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25297{
25298 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGPathSegArcRelConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25299}
25300
25301static inline JSValue jsDOMWindow_SVGPathSegClosePathConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25302{
25303 auto& vm = JSC::getVM(&lexicalGlobalObject);
25304 auto throwScope = DECLARE_THROW_SCOPE(vm);
25305 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25306 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25307 if (!shouldAllowAccess)
25308 return jsUndefined();
25309 return JSSVGPathSegClosePath::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25310}
25311
25312JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegClosePathConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25313{
25314 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGPathSegClosePathConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25315}
25316
25317static inline JSValue jsDOMWindow_SVGPathSegCurvetoCubicAbsConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25318{
25319 auto& vm = JSC::getVM(&lexicalGlobalObject);
25320 auto throwScope = DECLARE_THROW_SCOPE(vm);
25321 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25322 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25323 if (!shouldAllowAccess)
25324 return jsUndefined();
25325 return JSSVGPathSegCurvetoCubicAbs::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25326}
25327
25328JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegCurvetoCubicAbsConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25329{
25330 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGPathSegCurvetoCubicAbsConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25331}
25332
25333static inline JSValue jsDOMWindow_SVGPathSegCurvetoCubicRelConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25334{
25335 auto& vm = JSC::getVM(&lexicalGlobalObject);
25336 auto throwScope = DECLARE_THROW_SCOPE(vm);
25337 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25338 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25339 if (!shouldAllowAccess)
25340 return jsUndefined();
25341 return JSSVGPathSegCurvetoCubicRel::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25342}
25343
25344JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegCurvetoCubicRelConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25345{
25346 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGPathSegCurvetoCubicRelConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25347}
25348
25349static inline JSValue jsDOMWindow_SVGPathSegCurvetoCubicSmoothAbsConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25350{
25351 auto& vm = JSC::getVM(&lexicalGlobalObject);
25352 auto throwScope = DECLARE_THROW_SCOPE(vm);
25353 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25354 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25355 if (!shouldAllowAccess)
25356 return jsUndefined();
25357 return JSSVGPathSegCurvetoCubicSmoothAbs::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25358}
25359
25360JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegCurvetoCubicSmoothAbsConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25361{
25362 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGPathSegCurvetoCubicSmoothAbsConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25363}
25364
25365static inline JSValue jsDOMWindow_SVGPathSegCurvetoCubicSmoothRelConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25366{
25367 auto& vm = JSC::getVM(&lexicalGlobalObject);
25368 auto throwScope = DECLARE_THROW_SCOPE(vm);
25369 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25370 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25371 if (!shouldAllowAccess)
25372 return jsUndefined();
25373 return JSSVGPathSegCurvetoCubicSmoothRel::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25374}
25375
25376JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegCurvetoCubicSmoothRelConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25377{
25378 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGPathSegCurvetoCubicSmoothRelConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25379}
25380
25381static inline JSValue jsDOMWindow_SVGPathSegCurvetoQuadraticAbsConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25382{
25383 auto& vm = JSC::getVM(&lexicalGlobalObject);
25384 auto throwScope = DECLARE_THROW_SCOPE(vm);
25385 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25386 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25387 if (!shouldAllowAccess)
25388 return jsUndefined();
25389 return JSSVGPathSegCurvetoQuadraticAbs::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25390}
25391
25392JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegCurvetoQuadraticAbsConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25393{
25394 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGPathSegCurvetoQuadraticAbsConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25395}
25396
25397static inline JSValue jsDOMWindow_SVGPathSegCurvetoQuadraticRelConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25398{
25399 auto& vm = JSC::getVM(&lexicalGlobalObject);
25400 auto throwScope = DECLARE_THROW_SCOPE(vm);
25401 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25402 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25403 if (!shouldAllowAccess)
25404 return jsUndefined();
25405 return JSSVGPathSegCurvetoQuadraticRel::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25406}
25407
25408JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegCurvetoQuadraticRelConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25409{
25410 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGPathSegCurvetoQuadraticRelConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25411}
25412
25413static inline JSValue jsDOMWindow_SVGPathSegCurvetoQuadraticSmoothAbsConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25414{
25415 auto& vm = JSC::getVM(&lexicalGlobalObject);
25416 auto throwScope = DECLARE_THROW_SCOPE(vm);
25417 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25418 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25419 if (!shouldAllowAccess)
25420 return jsUndefined();
25421 return JSSVGPathSegCurvetoQuadraticSmoothAbs::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25422}
25423
25424JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegCurvetoQuadraticSmoothAbsConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25425{
25426 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGPathSegCurvetoQuadraticSmoothAbsConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25427}
25428
25429static inline JSValue jsDOMWindow_SVGPathSegCurvetoQuadraticSmoothRelConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25430{
25431 auto& vm = JSC::getVM(&lexicalGlobalObject);
25432 auto throwScope = DECLARE_THROW_SCOPE(vm);
25433 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25434 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25435 if (!shouldAllowAccess)
25436 return jsUndefined();
25437 return JSSVGPathSegCurvetoQuadraticSmoothRel::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25438}
25439
25440JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegCurvetoQuadraticSmoothRelConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25441{
25442 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGPathSegCurvetoQuadraticSmoothRelConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25443}
25444
25445static inline JSValue jsDOMWindow_SVGPathSegLinetoAbsConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25446{
25447 auto& vm = JSC::getVM(&lexicalGlobalObject);
25448 auto throwScope = DECLARE_THROW_SCOPE(vm);
25449 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25450 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25451 if (!shouldAllowAccess)
25452 return jsUndefined();
25453 return JSSVGPathSegLinetoAbs::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25454}
25455
25456JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegLinetoAbsConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25457{
25458 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGPathSegLinetoAbsConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25459}
25460
25461static inline JSValue jsDOMWindow_SVGPathSegLinetoHorizontalAbsConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25462{
25463 auto& vm = JSC::getVM(&lexicalGlobalObject);
25464 auto throwScope = DECLARE_THROW_SCOPE(vm);
25465 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25466 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25467 if (!shouldAllowAccess)
25468 return jsUndefined();
25469 return JSSVGPathSegLinetoHorizontalAbs::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25470}
25471
25472JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegLinetoHorizontalAbsConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25473{
25474 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGPathSegLinetoHorizontalAbsConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25475}
25476
25477static inline JSValue jsDOMWindow_SVGPathSegLinetoHorizontalRelConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25478{
25479 auto& vm = JSC::getVM(&lexicalGlobalObject);
25480 auto throwScope = DECLARE_THROW_SCOPE(vm);
25481 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25482 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25483 if (!shouldAllowAccess)
25484 return jsUndefined();
25485 return JSSVGPathSegLinetoHorizontalRel::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25486}
25487
25488JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegLinetoHorizontalRelConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25489{
25490 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGPathSegLinetoHorizontalRelConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25491}
25492
25493static inline JSValue jsDOMWindow_SVGPathSegLinetoRelConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25494{
25495 auto& vm = JSC::getVM(&lexicalGlobalObject);
25496 auto throwScope = DECLARE_THROW_SCOPE(vm);
25497 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25498 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25499 if (!shouldAllowAccess)
25500 return jsUndefined();
25501 return JSSVGPathSegLinetoRel::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25502}
25503
25504JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegLinetoRelConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25505{
25506 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGPathSegLinetoRelConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25507}
25508
25509static inline JSValue jsDOMWindow_SVGPathSegLinetoVerticalAbsConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25510{
25511 auto& vm = JSC::getVM(&lexicalGlobalObject);
25512 auto throwScope = DECLARE_THROW_SCOPE(vm);
25513 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25514 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25515 if (!shouldAllowAccess)
25516 return jsUndefined();
25517 return JSSVGPathSegLinetoVerticalAbs::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25518}
25519
25520JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegLinetoVerticalAbsConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25521{
25522 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGPathSegLinetoVerticalAbsConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25523}
25524
25525static inline JSValue jsDOMWindow_SVGPathSegLinetoVerticalRelConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25526{
25527 auto& vm = JSC::getVM(&lexicalGlobalObject);
25528 auto throwScope = DECLARE_THROW_SCOPE(vm);
25529 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25530 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25531 if (!shouldAllowAccess)
25532 return jsUndefined();
25533 return JSSVGPathSegLinetoVerticalRel::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25534}
25535
25536JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegLinetoVerticalRelConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25537{
25538 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGPathSegLinetoVerticalRelConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25539}
25540
25541static inline JSValue jsDOMWindow_SVGPathSegListConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25542{
25543 auto& vm = JSC::getVM(&lexicalGlobalObject);
25544 auto throwScope = DECLARE_THROW_SCOPE(vm);
25545 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25546 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25547 if (!shouldAllowAccess)
25548 return jsUndefined();
25549 return JSSVGPathSegList::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25550}
25551
25552JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegListConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25553{
25554 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGPathSegListConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25555}
25556
25557static inline JSValue jsDOMWindow_SVGPathSegMovetoAbsConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25558{
25559 auto& vm = JSC::getVM(&lexicalGlobalObject);
25560 auto throwScope = DECLARE_THROW_SCOPE(vm);
25561 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25562 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25563 if (!shouldAllowAccess)
25564 return jsUndefined();
25565 return JSSVGPathSegMovetoAbs::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25566}
25567
25568JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegMovetoAbsConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25569{
25570 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGPathSegMovetoAbsConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25571}
25572
25573static inline JSValue jsDOMWindow_SVGPathSegMovetoRelConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25574{
25575 auto& vm = JSC::getVM(&lexicalGlobalObject);
25576 auto throwScope = DECLARE_THROW_SCOPE(vm);
25577 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25578 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25579 if (!shouldAllowAccess)
25580 return jsUndefined();
25581 return JSSVGPathSegMovetoRel::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25582}
25583
25584JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGPathSegMovetoRelConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25585{
25586 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGPathSegMovetoRelConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25587}
25588
25589static inline JSValue jsDOMWindow_SVGPatternElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25590{
25591 auto& vm = JSC::getVM(&lexicalGlobalObject);
25592 auto throwScope = DECLARE_THROW_SCOPE(vm);
25593 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25594 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25595 if (!shouldAllowAccess)
25596 return jsUndefined();
25597 return JSSVGPatternElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25598}
25599
25600JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGPatternElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25601{
25602 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGPatternElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25603}
25604
25605static inline JSValue jsDOMWindow_SVGPointConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25606{
25607 auto& vm = JSC::getVM(&lexicalGlobalObject);
25608 auto throwScope = DECLARE_THROW_SCOPE(vm);
25609 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25610 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25611 if (!shouldAllowAccess)
25612 return jsUndefined();
25613 return JSSVGPoint::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25614}
25615
25616JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGPointConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25617{
25618 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGPointConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25619}
25620
25621static inline JSValue jsDOMWindow_SVGPointListConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25622{
25623 auto& vm = JSC::getVM(&lexicalGlobalObject);
25624 auto throwScope = DECLARE_THROW_SCOPE(vm);
25625 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25626 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25627 if (!shouldAllowAccess)
25628 return jsUndefined();
25629 return JSSVGPointList::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25630}
25631
25632JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGPointListConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25633{
25634 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGPointListConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25635}
25636
25637static inline JSValue jsDOMWindow_SVGPolygonElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25638{
25639 auto& vm = JSC::getVM(&lexicalGlobalObject);
25640 auto throwScope = DECLARE_THROW_SCOPE(vm);
25641 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25642 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25643 if (!shouldAllowAccess)
25644 return jsUndefined();
25645 return JSSVGPolygonElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25646}
25647
25648JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGPolygonElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25649{
25650 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGPolygonElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25651}
25652
25653static inline JSValue jsDOMWindow_SVGPolylineElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25654{
25655 auto& vm = JSC::getVM(&lexicalGlobalObject);
25656 auto throwScope = DECLARE_THROW_SCOPE(vm);
25657 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25658 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25659 if (!shouldAllowAccess)
25660 return jsUndefined();
25661 return JSSVGPolylineElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25662}
25663
25664JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGPolylineElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25665{
25666 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGPolylineElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25667}
25668
25669static inline JSValue jsDOMWindow_SVGPreserveAspectRatioConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25670{
25671 auto& vm = JSC::getVM(&lexicalGlobalObject);
25672 auto throwScope = DECLARE_THROW_SCOPE(vm);
25673 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25674 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25675 if (!shouldAllowAccess)
25676 return jsUndefined();
25677 return JSSVGPreserveAspectRatio::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25678}
25679
25680JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGPreserveAspectRatioConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25681{
25682 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGPreserveAspectRatioConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25683}
25684
25685static inline JSValue jsDOMWindow_SVGRadialGradientElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25686{
25687 auto& vm = JSC::getVM(&lexicalGlobalObject);
25688 auto throwScope = DECLARE_THROW_SCOPE(vm);
25689 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25690 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25691 if (!shouldAllowAccess)
25692 return jsUndefined();
25693 return JSSVGRadialGradientElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25694}
25695
25696JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGRadialGradientElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25697{
25698 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGRadialGradientElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25699}
25700
25701static inline JSValue jsDOMWindow_SVGRectConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25702{
25703 auto& vm = JSC::getVM(&lexicalGlobalObject);
25704 auto throwScope = DECLARE_THROW_SCOPE(vm);
25705 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25706 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25707 if (!shouldAllowAccess)
25708 return jsUndefined();
25709 return JSSVGRect::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25710}
25711
25712JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGRectConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25713{
25714 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGRectConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25715}
25716
25717static inline JSValue jsDOMWindow_SVGRectElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25718{
25719 auto& vm = JSC::getVM(&lexicalGlobalObject);
25720 auto throwScope = DECLARE_THROW_SCOPE(vm);
25721 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25722 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25723 if (!shouldAllowAccess)
25724 return jsUndefined();
25725 return JSSVGRectElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25726}
25727
25728JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGRectElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25729{
25730 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGRectElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25731}
25732
25733static inline JSValue jsDOMWindow_SVGRenderingIntentConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25734{
25735 auto& vm = JSC::getVM(&lexicalGlobalObject);
25736 auto throwScope = DECLARE_THROW_SCOPE(vm);
25737 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25738 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25739 if (!shouldAllowAccess)
25740 return jsUndefined();
25741 return JSSVGRenderingIntent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25742}
25743
25744JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGRenderingIntentConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25745{
25746 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGRenderingIntentConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25747}
25748
25749static inline JSValue jsDOMWindow_SVGSVGElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25750{
25751 auto& vm = JSC::getVM(&lexicalGlobalObject);
25752 auto throwScope = DECLARE_THROW_SCOPE(vm);
25753 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25754 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25755 if (!shouldAllowAccess)
25756 return jsUndefined();
25757 return JSSVGSVGElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25758}
25759
25760JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGSVGElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25761{
25762 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGSVGElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25763}
25764
25765static inline JSValue jsDOMWindow_SVGScriptElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25766{
25767 auto& vm = JSC::getVM(&lexicalGlobalObject);
25768 auto throwScope = DECLARE_THROW_SCOPE(vm);
25769 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25770 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25771 if (!shouldAllowAccess)
25772 return jsUndefined();
25773 return JSSVGScriptElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25774}
25775
25776JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGScriptElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25777{
25778 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGScriptElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25779}
25780
25781static inline JSValue jsDOMWindow_SVGSetElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25782{
25783 auto& vm = JSC::getVM(&lexicalGlobalObject);
25784 auto throwScope = DECLARE_THROW_SCOPE(vm);
25785 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25786 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25787 if (!shouldAllowAccess)
25788 return jsUndefined();
25789 return JSSVGSetElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25790}
25791
25792JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGSetElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25793{
25794 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGSetElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25795}
25796
25797static inline JSValue jsDOMWindow_SVGStopElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25798{
25799 auto& vm = JSC::getVM(&lexicalGlobalObject);
25800 auto throwScope = DECLARE_THROW_SCOPE(vm);
25801 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25802 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25803 if (!shouldAllowAccess)
25804 return jsUndefined();
25805 return JSSVGStopElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25806}
25807
25808JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGStopElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25809{
25810 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGStopElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25811}
25812
25813static inline JSValue jsDOMWindow_SVGStringListConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25814{
25815 auto& vm = JSC::getVM(&lexicalGlobalObject);
25816 auto throwScope = DECLARE_THROW_SCOPE(vm);
25817 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25818 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25819 if (!shouldAllowAccess)
25820 return jsUndefined();
25821 return JSSVGStringList::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25822}
25823
25824JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGStringListConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25825{
25826 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGStringListConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25827}
25828
25829static inline JSValue jsDOMWindow_SVGStyleElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25830{
25831 auto& vm = JSC::getVM(&lexicalGlobalObject);
25832 auto throwScope = DECLARE_THROW_SCOPE(vm);
25833 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25834 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25835 if (!shouldAllowAccess)
25836 return jsUndefined();
25837 return JSSVGStyleElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25838}
25839
25840JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGStyleElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25841{
25842 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGStyleElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25843}
25844
25845static inline JSValue jsDOMWindow_SVGSwitchElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25846{
25847 auto& vm = JSC::getVM(&lexicalGlobalObject);
25848 auto throwScope = DECLARE_THROW_SCOPE(vm);
25849 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25850 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25851 if (!shouldAllowAccess)
25852 return jsUndefined();
25853 return JSSVGSwitchElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25854}
25855
25856JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGSwitchElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25857{
25858 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGSwitchElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25859}
25860
25861static inline JSValue jsDOMWindow_SVGSymbolElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25862{
25863 auto& vm = JSC::getVM(&lexicalGlobalObject);
25864 auto throwScope = DECLARE_THROW_SCOPE(vm);
25865 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25866 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25867 if (!shouldAllowAccess)
25868 return jsUndefined();
25869 return JSSVGSymbolElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25870}
25871
25872JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGSymbolElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25873{
25874 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGSymbolElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25875}
25876
25877static inline JSValue jsDOMWindow_SVGTRefElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25878{
25879 auto& vm = JSC::getVM(&lexicalGlobalObject);
25880 auto throwScope = DECLARE_THROW_SCOPE(vm);
25881 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25882 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25883 if (!shouldAllowAccess)
25884 return jsUndefined();
25885 return JSSVGTRefElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25886}
25887
25888JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGTRefElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25889{
25890 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGTRefElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25891}
25892
25893static inline JSValue jsDOMWindow_SVGTSpanElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25894{
25895 auto& vm = JSC::getVM(&lexicalGlobalObject);
25896 auto throwScope = DECLARE_THROW_SCOPE(vm);
25897 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25898 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25899 if (!shouldAllowAccess)
25900 return jsUndefined();
25901 return JSSVGTSpanElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25902}
25903
25904JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGTSpanElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25905{
25906 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGTSpanElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25907}
25908
25909static inline JSValue jsDOMWindow_SVGTextContentElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25910{
25911 auto& vm = JSC::getVM(&lexicalGlobalObject);
25912 auto throwScope = DECLARE_THROW_SCOPE(vm);
25913 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25914 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25915 if (!shouldAllowAccess)
25916 return jsUndefined();
25917 return JSSVGTextContentElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25918}
25919
25920JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGTextContentElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25921{
25922 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGTextContentElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25923}
25924
25925static inline JSValue jsDOMWindow_SVGTextElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25926{
25927 auto& vm = JSC::getVM(&lexicalGlobalObject);
25928 auto throwScope = DECLARE_THROW_SCOPE(vm);
25929 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25930 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25931 if (!shouldAllowAccess)
25932 return jsUndefined();
25933 return JSSVGTextElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25934}
25935
25936JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGTextElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25937{
25938 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGTextElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25939}
25940
25941static inline JSValue jsDOMWindow_SVGTextPathElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25942{
25943 auto& vm = JSC::getVM(&lexicalGlobalObject);
25944 auto throwScope = DECLARE_THROW_SCOPE(vm);
25945 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25946 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25947 if (!shouldAllowAccess)
25948 return jsUndefined();
25949 return JSSVGTextPathElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25950}
25951
25952JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGTextPathElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25953{
25954 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGTextPathElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25955}
25956
25957static inline JSValue jsDOMWindow_SVGTextPositioningElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25958{
25959 auto& vm = JSC::getVM(&lexicalGlobalObject);
25960 auto throwScope = DECLARE_THROW_SCOPE(vm);
25961 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25962 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25963 if (!shouldAllowAccess)
25964 return jsUndefined();
25965 return JSSVGTextPositioningElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25966}
25967
25968JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGTextPositioningElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25969{
25970 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGTextPositioningElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25971}
25972
25973static inline JSValue jsDOMWindow_SVGTitleElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25974{
25975 auto& vm = JSC::getVM(&lexicalGlobalObject);
25976 auto throwScope = DECLARE_THROW_SCOPE(vm);
25977 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25978 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25979 if (!shouldAllowAccess)
25980 return jsUndefined();
25981 return JSSVGTitleElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25982}
25983
25984JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGTitleElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
25985{
25986 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGTitleElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
25987}
25988
25989static inline JSValue jsDOMWindow_SVGTransformConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
25990{
25991 auto& vm = JSC::getVM(&lexicalGlobalObject);
25992 auto throwScope = DECLARE_THROW_SCOPE(vm);
25993 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
25994 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
25995 if (!shouldAllowAccess)
25996 return jsUndefined();
25997 return JSSVGTransform::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
25998}
25999
26000JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGTransformConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
26001{
26002 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGTransformConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
26003}
26004
26005static inline JSValue jsDOMWindow_SVGTransformListConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
26006{
26007 auto& vm = JSC::getVM(&lexicalGlobalObject);
26008 auto throwScope = DECLARE_THROW_SCOPE(vm);
26009 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
26010 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26011 if (!shouldAllowAccess)
26012 return jsUndefined();
26013 return JSSVGTransformList::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
26014}
26015
26016JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGTransformListConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
26017{
26018 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGTransformListConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
26019}
26020
26021static inline JSValue jsDOMWindow_SVGUnitTypesConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
26022{
26023 auto& vm = JSC::getVM(&lexicalGlobalObject);
26024 auto throwScope = DECLARE_THROW_SCOPE(vm);
26025 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
26026 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26027 if (!shouldAllowAccess)
26028 return jsUndefined();
26029 return JSSVGUnitTypes::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
26030}
26031
26032JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGUnitTypesConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
26033{
26034 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGUnitTypesConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
26035}
26036
26037static inline JSValue jsDOMWindow_SVGUseElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
26038{
26039 auto& vm = JSC::getVM(&lexicalGlobalObject);
26040 auto throwScope = DECLARE_THROW_SCOPE(vm);
26041 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
26042 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26043 if (!shouldAllowAccess)
26044 return jsUndefined();
26045 return JSSVGUseElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
26046}
26047
26048JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGUseElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
26049{
26050 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGUseElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
26051}
26052
26053static inline JSValue jsDOMWindow_SVGVKernElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
26054{
26055 auto& vm = JSC::getVM(&lexicalGlobalObject);
26056 auto throwScope = DECLARE_THROW_SCOPE(vm);
26057 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
26058 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26059 if (!shouldAllowAccess)
26060 return jsUndefined();
26061 return JSSVGVKernElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
26062}
26063
26064JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGVKernElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
26065{
26066 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGVKernElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
26067}
26068
26069static inline JSValue jsDOMWindow_SVGViewElementConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
26070{
26071 auto& vm = JSC::getVM(&lexicalGlobalObject);
26072 auto throwScope = DECLARE_THROW_SCOPE(vm);
26073 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
26074 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26075 if (!shouldAllowAccess)
26076 return jsUndefined();
26077 return JSSVGViewElement::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
26078}
26079
26080JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGViewElementConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
26081{
26082 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGViewElementConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
26083}
26084
26085static inline JSValue jsDOMWindow_SVGViewSpecConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
26086{
26087 auto& vm = JSC::getVM(&lexicalGlobalObject);
26088 auto throwScope = DECLARE_THROW_SCOPE(vm);
26089 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
26090 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26091 if (!shouldAllowAccess)
26092 return jsUndefined();
26093 return JSSVGViewSpec::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
26094}
26095
26096JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGViewSpecConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
26097{
26098 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGViewSpecConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
26099}
26100
26101static inline JSValue jsDOMWindow_SVGZoomEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
26102{
26103 auto& vm = JSC::getVM(&lexicalGlobalObject);
26104 auto throwScope = DECLARE_THROW_SCOPE(vm);
26105 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
26106 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26107 if (!shouldAllowAccess)
26108 return jsUndefined();
26109 return JSSVGZoomEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
26110}
26111
26112JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_SVGZoomEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
26113{
26114 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_SVGZoomEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
26115}
26116
26117static inline JSValue jsDOMWindow_WorkerConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
26118{
26119 auto& vm = JSC::getVM(&lexicalGlobalObject);
26120 auto throwScope = DECLARE_THROW_SCOPE(vm);
26121 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
26122 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26123 if (!shouldAllowAccess)
26124 return jsUndefined();
26125 return JSWorker::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
26126}
26127
26128JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WorkerConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
26129{
26130 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WorkerConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
26131}
26132
26133#if ENABLE(SERVICE_WORKER)
26134static inline JSValue jsDOMWindow_ServiceWorkerConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
26135{
26136 auto& vm = JSC::getVM(&lexicalGlobalObject);
26137 auto throwScope = DECLARE_THROW_SCOPE(vm);
26138 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
26139 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26140 if (!shouldAllowAccess)
26141 return jsUndefined();
26142 return JSServiceWorker::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
26143}
26144
26145JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ServiceWorkerConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
26146{
26147 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ServiceWorkerConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
26148}
26149
26150#endif
26151
26152#if ENABLE(SERVICE_WORKER)
26153static inline JSValue jsDOMWindow_ServiceWorkerContainerConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
26154{
26155 auto& vm = JSC::getVM(&lexicalGlobalObject);
26156 auto throwScope = DECLARE_THROW_SCOPE(vm);
26157 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
26158 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26159 if (!shouldAllowAccess)
26160 return jsUndefined();
26161 return JSServiceWorkerContainer::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
26162}
26163
26164JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ServiceWorkerContainerConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
26165{
26166 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ServiceWorkerContainerConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
26167}
26168
26169#endif
26170
26171#if ENABLE(SERVICE_WORKER)
26172static inline JSValue jsDOMWindow_ServiceWorkerRegistrationConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
26173{
26174 auto& vm = JSC::getVM(&lexicalGlobalObject);
26175 auto throwScope = DECLARE_THROW_SCOPE(vm);
26176 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
26177 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26178 if (!shouldAllowAccess)
26179 return jsUndefined();
26180 return JSServiceWorkerRegistration::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
26181}
26182
26183JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_ServiceWorkerRegistrationConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
26184{
26185 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_ServiceWorkerRegistrationConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
26186}
26187
26188#endif
26189
26190static inline JSValue jsDOMWindow_WorkletConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
26191{
26192 auto& vm = JSC::getVM(&lexicalGlobalObject);
26193 auto throwScope = DECLARE_THROW_SCOPE(vm);
26194 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
26195 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26196 if (!shouldAllowAccess)
26197 return jsUndefined();
26198 return JSWorklet::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
26199}
26200
26201JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_WorkletConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
26202{
26203 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_WorkletConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
26204}
26205
26206static inline JSValue jsDOMWindow_DOMParserConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
26207{
26208 auto& vm = JSC::getVM(&lexicalGlobalObject);
26209 auto throwScope = DECLARE_THROW_SCOPE(vm);
26210 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
26211 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26212 if (!shouldAllowAccess)
26213 return jsUndefined();
26214 return JSDOMParser::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
26215}
26216
26217JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_DOMParserConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
26218{
26219 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_DOMParserConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
26220}
26221
26222static inline JSValue jsDOMWindow_XMLHttpRequestConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
26223{
26224 auto& vm = JSC::getVM(&lexicalGlobalObject);
26225 auto throwScope = DECLARE_THROW_SCOPE(vm);
26226 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
26227 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26228 if (!shouldAllowAccess)
26229 return jsUndefined();
26230 return JSXMLHttpRequest::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
26231}
26232
26233JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_XMLHttpRequestConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
26234{
26235 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_XMLHttpRequestConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
26236}
26237
26238static inline JSValue jsDOMWindow_XMLHttpRequestEventTargetConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
26239{
26240 auto& vm = JSC::getVM(&lexicalGlobalObject);
26241 auto throwScope = DECLARE_THROW_SCOPE(vm);
26242 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
26243 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26244 if (!shouldAllowAccess)
26245 return jsUndefined();
26246 return JSXMLHttpRequestEventTarget::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
26247}
26248
26249JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_XMLHttpRequestEventTargetConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
26250{
26251 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_XMLHttpRequestEventTargetConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
26252}
26253
26254static inline JSValue jsDOMWindow_XMLHttpRequestProgressEventConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
26255{
26256 auto& vm = JSC::getVM(&lexicalGlobalObject);
26257 auto throwScope = DECLARE_THROW_SCOPE(vm);
26258 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
26259 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26260 if (!shouldAllowAccess)
26261 return jsUndefined();
26262 return JSXMLHttpRequestProgressEvent::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
26263}
26264
26265JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_XMLHttpRequestProgressEventConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
26266{
26267 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_XMLHttpRequestProgressEventConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
26268}
26269
26270static inline JSValue jsDOMWindow_XMLHttpRequestUploadConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
26271{
26272 auto& vm = JSC::getVM(&lexicalGlobalObject);
26273 auto throwScope = DECLARE_THROW_SCOPE(vm);
26274 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
26275 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26276 if (!shouldAllowAccess)
26277 return jsUndefined();
26278 return JSXMLHttpRequestUpload::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
26279}
26280
26281JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_XMLHttpRequestUploadConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
26282{
26283 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_XMLHttpRequestUploadConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
26284}
26285
26286static inline JSValue jsDOMWindow_XMLSerializerConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
26287{
26288 auto& vm = JSC::getVM(&lexicalGlobalObject);
26289 auto throwScope = DECLARE_THROW_SCOPE(vm);
26290 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
26291 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26292 if (!shouldAllowAccess)
26293 return jsUndefined();
26294 return JSXMLSerializer::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
26295}
26296
26297JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_XMLSerializerConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
26298{
26299 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_XMLSerializerConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
26300}
26301
26302static inline JSValue jsDOMWindow_XPathEvaluatorConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
26303{
26304 auto& vm = JSC::getVM(&lexicalGlobalObject);
26305 auto throwScope = DECLARE_THROW_SCOPE(vm);
26306 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
26307 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26308 if (!shouldAllowAccess)
26309 return jsUndefined();
26310 return JSXPathEvaluator::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
26311}
26312
26313JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_XPathEvaluatorConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
26314{
26315 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_XPathEvaluatorConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
26316}
26317
26318static inline JSValue jsDOMWindow_XPathExpressionConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
26319{
26320 auto& vm = JSC::getVM(&lexicalGlobalObject);
26321 auto throwScope = DECLARE_THROW_SCOPE(vm);
26322 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
26323 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26324 if (!shouldAllowAccess)
26325 return jsUndefined();
26326 return JSXPathExpression::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
26327}
26328
26329JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_XPathExpressionConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
26330{
26331 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_XPathExpressionConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
26332}
26333
26334static inline JSValue jsDOMWindow_XPathResultConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
26335{
26336 auto& vm = JSC::getVM(&lexicalGlobalObject);
26337 auto throwScope = DECLARE_THROW_SCOPE(vm);
26338 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
26339 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26340 if (!shouldAllowAccess)
26341 return jsUndefined();
26342 return JSXPathResult::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
26343}
26344
26345JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_XPathResultConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
26346{
26347 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_XPathResultConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
26348}
26349
26350#if ENABLE(XSLT)
26351static inline JSValue jsDOMWindow_XSLTProcessorConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSDOMWindow& thisObject)
26352{
26353 auto& vm = JSC::getVM(&lexicalGlobalObject);
26354 auto throwScope = DECLARE_THROW_SCOPE(vm);
26355 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(&lexicalGlobalObject, thisObject, ThrowSecurityError);
26356 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26357 if (!shouldAllowAccess)
26358 return jsUndefined();
26359 return JSXSLTProcessor::getConstructor(JSC::getVM(&lexicalGlobalObject), &thisObject);
26360}
26361
26362JSC_DEFINE_CUSTOM_GETTER(jsDOMWindow_XSLTProcessorConstructor, (JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
26363{
26364 return IDLAttribute<JSDOMWindow>::get<jsDOMWindow_XSLTProcessorConstructorGetter>(*lexicalGlobalObject, thisValue, attributeName);
26365}
26366
26367#endif
26368
26369static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_closeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
26370{
26371 auto& vm = JSC::getVM(lexicalGlobalObject);
26372 auto throwScope = DECLARE_THROW_SCOPE(vm);
26373 UNUSED_PARAM(throwScope);
26374 UNUSED_PARAM(callFrame);
26375 auto& impl = castedThis->wrapped();
26376 auto* incumbentDocument = incumbentDOMWindow(*jsCast<JSDOMGlobalObject*>(lexicalGlobalObject), *callFrame).document();
26377 if (!incumbentDocument)
26378 return JSValue::encode(jsUndefined());
26379 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.close(*incumbentDocument); })));
26380}
26381
26382JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_close, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
26383{
26384 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_closeBody>(*lexicalGlobalObject, *callFrame, "close");
26385}
26386
26387static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_stopBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
26388{
26389 auto& vm = JSC::getVM(lexicalGlobalObject);
26390 auto throwScope = DECLARE_THROW_SCOPE(vm);
26391 UNUSED_PARAM(throwScope);
26392 UNUSED_PARAM(callFrame);
26393 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
26394 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26395 if (!shouldAllowAccess)
26396 return JSValue::encode(jsUndefined());
26397 auto& impl = castedThis->wrapped();
26398 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.stop(); })));
26399}
26400
26401JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_stop, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
26402{
26403 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_stopBody>(*lexicalGlobalObject, *callFrame, "stop");
26404}
26405
26406static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_focusBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
26407{
26408 auto& vm = JSC::getVM(lexicalGlobalObject);
26409 auto throwScope = DECLARE_THROW_SCOPE(vm);
26410 UNUSED_PARAM(throwScope);
26411 UNUSED_PARAM(callFrame);
26412 auto& impl = castedThis->wrapped();
26413 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.focus(incumbentDOMWindow(*jsCast<JSDOMGlobalObject*>(lexicalGlobalObject), *callFrame)); })));
26414}
26415
26416JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_focus, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
26417{
26418 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_focusBody>(*lexicalGlobalObject, *callFrame, "focus");
26419}
26420
26421static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_blurBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
26422{
26423 auto& vm = JSC::getVM(lexicalGlobalObject);
26424 auto throwScope = DECLARE_THROW_SCOPE(vm);
26425 UNUSED_PARAM(throwScope);
26426 UNUSED_PARAM(callFrame);
26427 auto& impl = castedThis->wrapped();
26428 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.blur(); })));
26429}
26430
26431JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_blur, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
26432{
26433 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_blurBody>(*lexicalGlobalObject, *callFrame, "blur");
26434}
26435
26436static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_openBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
26437{
26438 auto& vm = JSC::getVM(lexicalGlobalObject);
26439 auto throwScope = DECLARE_THROW_SCOPE(vm);
26440 UNUSED_PARAM(throwScope);
26441 UNUSED_PARAM(callFrame);
26442 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
26443 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26444 if (!shouldAllowAccess)
26445 return JSValue::encode(jsUndefined());
26446 auto& impl = castedThis->wrapped();
26447 EnsureStillAliveScope argument0 = callFrame->argument(0);
26448 auto url = argument0.value().isUndefined() ? emptyString() : convert<IDLUSVString>(*lexicalGlobalObject, argument0.value());
26449 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
26450 EnsureStillAliveScope argument1 = callFrame->argument(1);
26451 auto target = argument1.value().isUndefined() ? "_blank"_s : convert<IDLDOMString>(*lexicalGlobalObject, argument1.value());
26452 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
26453 EnsureStillAliveScope argument2 = callFrame->argument(2);
26454 auto features = argument2.value().isUndefined() ? emptyString() : convert<IDLLegacyNullToEmptyStringAdaptor<IDLDOMString>>(*lexicalGlobalObject, argument2.value());
26455 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
26456 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLNullable<IDLInterface<WindowProxy>>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.open(activeDOMWindow(*jsCast<JSDOMGlobalObject*>(lexicalGlobalObject)), firstDOMWindow(*jsCast<JSDOMGlobalObject*>(lexicalGlobalObject)), WTFMove(url), WTFMove(target), WTFMove(features)))));
26457}
26458
26459JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_open, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
26460{
26461 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_openBody>(*lexicalGlobalObject, *callFrame, "open");
26462}
26463
26464static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_alert1Body(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
26465{
26466 auto& vm = JSC::getVM(lexicalGlobalObject);
26467 auto throwScope = DECLARE_THROW_SCOPE(vm);
26468 UNUSED_PARAM(throwScope);
26469 UNUSED_PARAM(callFrame);
26470 auto& impl = castedThis->wrapped();
26471 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.alert(); })));
26472}
26473
26474static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_alert2Body(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
26475{
26476 auto& vm = JSC::getVM(lexicalGlobalObject);
26477 auto throwScope = DECLARE_THROW_SCOPE(vm);
26478 UNUSED_PARAM(throwScope);
26479 UNUSED_PARAM(callFrame);
26480 auto& impl = castedThis->wrapped();
26481 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
26482 auto message = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
26483 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
26484 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.alert(WTFMove(message)); })));
26485}
26486
26487static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_alertOverloadDispatcher(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
26488{
26489 auto& vm = JSC::getVM(lexicalGlobalObject);
26490 auto throwScope = DECLARE_THROW_SCOPE(vm);
26491 UNUSED_PARAM(throwScope);
26492 UNUSED_PARAM(callFrame);
26493 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
26494 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26495 if (!shouldAllowAccess)
26496 return JSValue::encode(jsUndefined());
26497 size_t argsCount = std::min<size_t>(1, callFrame->argumentCount());
26498 if (argsCount == 0) {
26499 RELEASE_AND_RETURN(throwScope, (jsDOMWindowInstanceFunction_alert1Body(lexicalGlobalObject, callFrame, castedThis)));
26500 }
26501 if (argsCount == 1) {
26502 RELEASE_AND_RETURN(throwScope, (jsDOMWindowInstanceFunction_alert2Body(lexicalGlobalObject, callFrame, castedThis)));
26503 }
26504 return throwVMTypeError(lexicalGlobalObject, throwScope);
26505}
26506
26507JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_alert, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
26508{
26509 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_alertOverloadDispatcher>(*lexicalGlobalObject, *callFrame, "alert");
26510}
26511
26512static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_confirmBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
26513{
26514 auto& vm = JSC::getVM(lexicalGlobalObject);
26515 auto throwScope = DECLARE_THROW_SCOPE(vm);
26516 UNUSED_PARAM(throwScope);
26517 UNUSED_PARAM(callFrame);
26518 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
26519 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26520 if (!shouldAllowAccess)
26521 return JSValue::encode(jsUndefined());
26522 auto& impl = castedThis->wrapped();
26523 EnsureStillAliveScope argument0 = callFrame->argument(0);
26524 auto message = argument0.value().isUndefined() ? emptyString() : convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
26525 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
26526 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.confirmForBindings(WTFMove(message)))));
26527}
26528
26529JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_confirm, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
26530{
26531 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_confirmBody>(*lexicalGlobalObject, *callFrame, "confirm");
26532}
26533
26534static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_promptBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
26535{
26536 auto& vm = JSC::getVM(lexicalGlobalObject);
26537 auto throwScope = DECLARE_THROW_SCOPE(vm);
26538 UNUSED_PARAM(throwScope);
26539 UNUSED_PARAM(callFrame);
26540 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
26541 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26542 if (!shouldAllowAccess)
26543 return JSValue::encode(jsUndefined());
26544 auto& impl = castedThis->wrapped();
26545 EnsureStillAliveScope argument0 = callFrame->argument(0);
26546 auto message = argument0.value().isUndefined() ? emptyString() : convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
26547 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
26548 EnsureStillAliveScope argument1 = callFrame->argument(1);
26549 auto defaultValue = argument1.value().isUndefined() ? emptyString() : convert<IDLDOMString>(*lexicalGlobalObject, argument1.value());
26550 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
26551 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLNullable<IDLDOMString>>(*lexicalGlobalObject, throwScope, impl.prompt(WTFMove(message), WTFMove(defaultValue)))));
26552}
26553
26554JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_prompt, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
26555{
26556 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_promptBody>(*lexicalGlobalObject, *callFrame, "prompt");
26557}
26558
26559static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_printBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
26560{
26561 auto& vm = JSC::getVM(lexicalGlobalObject);
26562 auto throwScope = DECLARE_THROW_SCOPE(vm);
26563 UNUSED_PARAM(throwScope);
26564 UNUSED_PARAM(callFrame);
26565 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
26566 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26567 if (!shouldAllowAccess)
26568 return JSValue::encode(jsUndefined());
26569 auto& impl = castedThis->wrapped();
26570 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.print(); })));
26571}
26572
26573JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_print, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
26574{
26575 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_printBody>(*lexicalGlobalObject, *callFrame, "print");
26576}
26577
26578static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_postMessage1Body(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
26579{
26580 auto& vm = JSC::getVM(lexicalGlobalObject);
26581 auto throwScope = DECLARE_THROW_SCOPE(vm);
26582 UNUSED_PARAM(throwScope);
26583 UNUSED_PARAM(callFrame);
26584 auto& impl = castedThis->wrapped();
26585 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
26586 auto message = convert<IDLAny>(*lexicalGlobalObject, argument0.value());
26587 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
26588 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
26589 auto targetOrigin = convert<IDLUSVString>(*lexicalGlobalObject, argument1.value());
26590 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
26591 EnsureStillAliveScope argument2 = callFrame->argument(2);
26592 auto transfer = argument2.value().isUndefined() ? Converter<IDLSequence<IDLObject>>::ReturnType{ } : convert<IDLSequence<IDLObject>>(*lexicalGlobalObject, argument2.value());
26593 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
26594 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.postMessage(*jsCast<JSDOMGlobalObject*>(lexicalGlobalObject), incumbentDOMWindow(*jsCast<JSDOMGlobalObject*>(lexicalGlobalObject), *callFrame), WTFMove(message), WTFMove(targetOrigin), WTFMove(transfer)); })));
26595}
26596
26597static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_postMessage2Body(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
26598{
26599 auto& vm = JSC::getVM(lexicalGlobalObject);
26600 auto throwScope = DECLARE_THROW_SCOPE(vm);
26601 UNUSED_PARAM(throwScope);
26602 UNUSED_PARAM(callFrame);
26603 auto& impl = castedThis->wrapped();
26604 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
26605 auto message = convert<IDLAny>(*lexicalGlobalObject, argument0.value());
26606 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
26607 EnsureStillAliveScope argument1 = callFrame->argument(1);
26608 auto options = convert<IDLDictionary<WindowPostMessageOptions>>(*lexicalGlobalObject, argument1.value());
26609 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
26610 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.postMessage(*jsCast<JSDOMGlobalObject*>(lexicalGlobalObject), incumbentDOMWindow(*jsCast<JSDOMGlobalObject*>(lexicalGlobalObject), *callFrame), WTFMove(message), WTFMove(options)); })));
26611}
26612
26613static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_postMessageOverloadDispatcher(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
26614{
26615 auto& vm = JSC::getVM(lexicalGlobalObject);
26616 auto throwScope = DECLARE_THROW_SCOPE(vm);
26617 UNUSED_PARAM(throwScope);
26618 UNUSED_PARAM(callFrame);
26619 size_t argsCount = std::min<size_t>(3, callFrame->argumentCount());
26620 if (argsCount == 1) {
26621 RELEASE_AND_RETURN(throwScope, (jsDOMWindowInstanceFunction_postMessage2Body(lexicalGlobalObject, callFrame, castedThis)));
26622 }
26623 if (argsCount == 2) {
26624 JSValue distinguishingArg = callFrame->uncheckedArgument(1);
26625 if (distinguishingArg.isUndefined())
26626 RELEASE_AND_RETURN(throwScope, (jsDOMWindowInstanceFunction_postMessage2Body(lexicalGlobalObject, callFrame, castedThis)));
26627 if (distinguishingArg.isUndefinedOrNull())
26628 RELEASE_AND_RETURN(throwScope, (jsDOMWindowInstanceFunction_postMessage2Body(lexicalGlobalObject, callFrame, castedThis)));
26629 if (distinguishingArg.isObject())
26630 RELEASE_AND_RETURN(throwScope, (jsDOMWindowInstanceFunction_postMessage2Body(lexicalGlobalObject, callFrame, castedThis)));
26631 RELEASE_AND_RETURN(throwScope, (jsDOMWindowInstanceFunction_postMessage1Body(lexicalGlobalObject, callFrame, castedThis)));
26632 }
26633 if (argsCount == 3) {
26634 RELEASE_AND_RETURN(throwScope, (jsDOMWindowInstanceFunction_postMessage1Body(lexicalGlobalObject, callFrame, castedThis)));
26635 }
26636 return argsCount < 1 ? throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject)) : throwVMTypeError(lexicalGlobalObject, throwScope);
26637}
26638
26639JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_postMessage, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
26640{
26641 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_postMessageOverloadDispatcher>(*lexicalGlobalObject, *callFrame, "postMessage");
26642}
26643
26644static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_captureEventsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
26645{
26646 auto& vm = JSC::getVM(lexicalGlobalObject);
26647 auto throwScope = DECLARE_THROW_SCOPE(vm);
26648 UNUSED_PARAM(throwScope);
26649 UNUSED_PARAM(callFrame);
26650 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
26651 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26652 if (!shouldAllowAccess)
26653 return JSValue::encode(jsUndefined());
26654 auto& impl = castedThis->wrapped();
26655 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.captureEvents(); })));
26656}
26657
26658JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_captureEvents, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
26659{
26660 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_captureEventsBody>(*lexicalGlobalObject, *callFrame, "captureEvents");
26661}
26662
26663static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_releaseEventsBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
26664{
26665 auto& vm = JSC::getVM(lexicalGlobalObject);
26666 auto throwScope = DECLARE_THROW_SCOPE(vm);
26667 UNUSED_PARAM(throwScope);
26668 UNUSED_PARAM(callFrame);
26669 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
26670 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26671 if (!shouldAllowAccess)
26672 return JSValue::encode(jsUndefined());
26673 auto& impl = castedThis->wrapped();
26674 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.releaseEvents(); })));
26675}
26676
26677JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_releaseEvents, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
26678{
26679 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_releaseEventsBody>(*lexicalGlobalObject, *callFrame, "releaseEvents");
26680}
26681
26682static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_findBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
26683{
26684 auto& vm = JSC::getVM(lexicalGlobalObject);
26685 auto throwScope = DECLARE_THROW_SCOPE(vm);
26686 UNUSED_PARAM(throwScope);
26687 UNUSED_PARAM(callFrame);
26688 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
26689 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26690 if (!shouldAllowAccess)
26691 return JSValue::encode(jsUndefined());
26692 auto& impl = castedThis->wrapped();
26693 EnsureStillAliveScope argument0 = callFrame->argument(0);
26694 auto string = argument0.value().isUndefined() ? String() : convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
26695 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
26696 EnsureStillAliveScope argument1 = callFrame->argument(1);
26697 auto caseSensitive = convert<IDLBoolean>(*lexicalGlobalObject, argument1.value());
26698 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
26699 EnsureStillAliveScope argument2 = callFrame->argument(2);
26700 auto backwards = convert<IDLBoolean>(*lexicalGlobalObject, argument2.value());
26701 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
26702 EnsureStillAliveScope argument3 = callFrame->argument(3);
26703 auto wrap = convert<IDLBoolean>(*lexicalGlobalObject, argument3.value());
26704 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
26705 EnsureStillAliveScope argument4 = callFrame->argument(4);
26706 auto wholeWord = convert<IDLBoolean>(*lexicalGlobalObject, argument4.value());
26707 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
26708 EnsureStillAliveScope argument5 = callFrame->argument(5);
26709 auto searchInFrames = convert<IDLBoolean>(*lexicalGlobalObject, argument5.value());
26710 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
26711 EnsureStillAliveScope argument6 = callFrame->argument(6);
26712 auto showDialog = convert<IDLBoolean>(*lexicalGlobalObject, argument6.value());
26713 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
26714 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLBoolean>(*lexicalGlobalObject, throwScope, impl.find(WTFMove(string), WTFMove(caseSensitive), WTFMove(backwards), WTFMove(wrap), WTFMove(wholeWord), WTFMove(searchInFrames), WTFMove(showDialog)))));
26715}
26716
26717JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_find, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
26718{
26719 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_findBody>(*lexicalGlobalObject, *callFrame, "find");
26720}
26721
26722static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_webkitRequestAnimationFrameBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
26723{
26724 auto& vm = JSC::getVM(lexicalGlobalObject);
26725 auto throwScope = DECLARE_THROW_SCOPE(vm);
26726 UNUSED_PARAM(throwScope);
26727 UNUSED_PARAM(callFrame);
26728 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
26729 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26730 if (!shouldAllowAccess)
26731 return JSValue::encode(jsUndefined());
26732 auto& impl = castedThis->wrapped();
26733 if (UNLIKELY(callFrame->argumentCount() < 1))
26734 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
26735 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
26736 auto callback = convert<IDLCallbackFunction<JSRequestAnimationFrameCallback>>(*lexicalGlobalObject, argument0.value(), *castedThis->globalObject(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeFunctionError(lexicalGlobalObject, scope, 0, "callback", "Window", "webkitRequestAnimationFrame"); });
26737 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
26738 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLLong>(*lexicalGlobalObject, throwScope, impl.webkitRequestAnimationFrame(callback.releaseNonNull()))));
26739}
26740
26741JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_webkitRequestAnimationFrame, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
26742{
26743 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_webkitRequestAnimationFrameBody>(*lexicalGlobalObject, *callFrame, "webkitRequestAnimationFrame");
26744}
26745
26746static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_webkitCancelAnimationFrameBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
26747{
26748 auto& vm = JSC::getVM(lexicalGlobalObject);
26749 auto throwScope = DECLARE_THROW_SCOPE(vm);
26750 UNUSED_PARAM(throwScope);
26751 UNUSED_PARAM(callFrame);
26752 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
26753 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26754 if (!shouldAllowAccess)
26755 return JSValue::encode(jsUndefined());
26756 auto& impl = castedThis->wrapped();
26757 if (UNLIKELY(callFrame->argumentCount() < 1))
26758 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
26759 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
26760 auto id = convert<IDLLong>(*lexicalGlobalObject, argument0.value());
26761 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
26762 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.cancelAnimationFrame(WTFMove(id)); })));
26763}
26764
26765JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_webkitCancelAnimationFrame, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
26766{
26767 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_webkitCancelAnimationFrameBody>(*lexicalGlobalObject, *callFrame, "webkitCancelAnimationFrame");
26768}
26769
26770static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_webkitCancelRequestAnimationFrameBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
26771{
26772 auto& vm = JSC::getVM(lexicalGlobalObject);
26773 auto throwScope = DECLARE_THROW_SCOPE(vm);
26774 UNUSED_PARAM(throwScope);
26775 UNUSED_PARAM(callFrame);
26776 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
26777 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26778 if (!shouldAllowAccess)
26779 return JSValue::encode(jsUndefined());
26780 auto& impl = castedThis->wrapped();
26781 if (UNLIKELY(callFrame->argumentCount() < 1))
26782 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
26783 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
26784 auto id = convert<IDLLong>(*lexicalGlobalObject, argument0.value());
26785 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
26786 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.cancelAnimationFrame(WTFMove(id)); })));
26787}
26788
26789JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_webkitCancelRequestAnimationFrame, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
26790{
26791 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_webkitCancelRequestAnimationFrameBody>(*lexicalGlobalObject, *callFrame, "webkitCancelRequestAnimationFrame");
26792}
26793
26794static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_showModalDialogBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
26795{
26796 auto& vm = JSC::getVM(lexicalGlobalObject);
26797 auto throwScope = DECLARE_THROW_SCOPE(vm);
26798 UNUSED_PARAM(throwScope);
26799 UNUSED_PARAM(callFrame);
26800 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
26801 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26802 if (!shouldAllowAccess)
26803 return JSValue::encode(jsUndefined());
26804 RELEASE_AND_RETURN(throwScope, (JSValue::encode(castedThis->showModalDialog(*lexicalGlobalObject, *callFrame))));
26805}
26806
26807JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_showModalDialog, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
26808{
26809 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_showModalDialogBody>(*lexicalGlobalObject, *callFrame, "showModalDialog");
26810}
26811
26812static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_getMatchedCSSRulesBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
26813{
26814 auto& vm = JSC::getVM(lexicalGlobalObject);
26815 auto throwScope = DECLARE_THROW_SCOPE(vm);
26816 UNUSED_PARAM(throwScope);
26817 UNUSED_PARAM(callFrame);
26818 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
26819 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26820 if (!shouldAllowAccess)
26821 return JSValue::encode(jsUndefined());
26822 auto& impl = castedThis->wrapped();
26823 EnsureStillAliveScope argument0 = callFrame->argument(0);
26824 auto element = convert<IDLNullable<IDLInterface<Element>>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Window", "getMatchedCSSRules", "Element"); });
26825 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
26826 EnsureStillAliveScope argument1 = callFrame->argument(1);
26827 auto pseudoElement = argument1.value().isUndefined() ? String() : convert<IDLNullable<IDLDOMString>>(*lexicalGlobalObject, argument1.value());
26828 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
26829 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLInterface<CSSRuleList>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.getMatchedCSSRules(WTFMove(element), WTFMove(pseudoElement)))));
26830}
26831
26832JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_getMatchedCSSRules, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
26833{
26834 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_getMatchedCSSRulesBody>(*lexicalGlobalObject, *callFrame, "getMatchedCSSRules");
26835}
26836
26837static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_webkitConvertPointFromPageToNodeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
26838{
26839 auto& vm = JSC::getVM(lexicalGlobalObject);
26840 auto throwScope = DECLARE_THROW_SCOPE(vm);
26841 UNUSED_PARAM(throwScope);
26842 UNUSED_PARAM(callFrame);
26843 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
26844 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26845 if (!shouldAllowAccess)
26846 return JSValue::encode(jsUndefined());
26847 auto& impl = castedThis->wrapped();
26848 EnsureStillAliveScope argument0 = callFrame->argument(0);
26849 auto node = convert<IDLNullable<IDLInterface<Node>>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "node", "Window", "webkitConvertPointFromPageToNode", "Node"); });
26850 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
26851 EnsureStillAliveScope argument1 = callFrame->argument(1);
26852 auto p = convert<IDLNullable<IDLInterface<WebKitPoint>>>(*lexicalGlobalObject, argument1.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 1, "p", "Window", "webkitConvertPointFromPageToNode", "WebKitPoint"); });
26853 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
26854 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLInterface<WebKitPoint>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.webkitConvertPointFromPageToNode(WTFMove(node), WTFMove(p)))));
26855}
26856
26857JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_webkitConvertPointFromPageToNode, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
26858{
26859 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_webkitConvertPointFromPageToNodeBody>(*lexicalGlobalObject, *callFrame, "webkitConvertPointFromPageToNode");
26860}
26861
26862static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_webkitConvertPointFromNodeToPageBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
26863{
26864 auto& vm = JSC::getVM(lexicalGlobalObject);
26865 auto throwScope = DECLARE_THROW_SCOPE(vm);
26866 UNUSED_PARAM(throwScope);
26867 UNUSED_PARAM(callFrame);
26868 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
26869 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26870 if (!shouldAllowAccess)
26871 return JSValue::encode(jsUndefined());
26872 auto& impl = castedThis->wrapped();
26873 EnsureStillAliveScope argument0 = callFrame->argument(0);
26874 auto node = convert<IDLNullable<IDLInterface<Node>>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "node", "Window", "webkitConvertPointFromNodeToPage", "Node"); });
26875 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
26876 EnsureStillAliveScope argument1 = callFrame->argument(1);
26877 auto p = convert<IDLNullable<IDLInterface<WebKitPoint>>>(*lexicalGlobalObject, argument1.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 1, "p", "Window", "webkitConvertPointFromNodeToPage", "WebKitPoint"); });
26878 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
26879 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLInterface<WebKitPoint>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.webkitConvertPointFromNodeToPage(WTFMove(node), WTFMove(p)))));
26880}
26881
26882JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_webkitConvertPointFromNodeToPage, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
26883{
26884 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_webkitConvertPointFromNodeToPageBody>(*lexicalGlobalObject, *callFrame, "webkitConvertPointFromNodeToPage");
26885}
26886
26887static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_collectMatchingElementsInFlatTreeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
26888{
26889 auto& vm = JSC::getVM(lexicalGlobalObject);
26890 auto throwScope = DECLARE_THROW_SCOPE(vm);
26891 UNUSED_PARAM(throwScope);
26892 UNUSED_PARAM(callFrame);
26893 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
26894 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26895 if (!shouldAllowAccess)
26896 return JSValue::encode(jsUndefined());
26897 auto& impl = castedThis->wrapped();
26898 if (UNLIKELY(callFrame->argumentCount() < 2))
26899 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
26900 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
26901 auto scope = convert<IDLInterface<Node>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "scope", "Window", "collectMatchingElementsInFlatTree", "Node"); });
26902 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
26903 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
26904 auto selectors = convert<IDLDOMString>(*lexicalGlobalObject, argument1.value());
26905 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
26906 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLInterface<NodeList>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.collectMatchingElementsInFlatTree(*scope, WTFMove(selectors)))));
26907}
26908
26909JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_collectMatchingElementsInFlatTree, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
26910{
26911 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_collectMatchingElementsInFlatTreeBody>(*lexicalGlobalObject, *callFrame, "collectMatchingElementsInFlatTree");
26912}
26913
26914static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_matchingElementInFlatTreeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
26915{
26916 auto& vm = JSC::getVM(lexicalGlobalObject);
26917 auto throwScope = DECLARE_THROW_SCOPE(vm);
26918 UNUSED_PARAM(throwScope);
26919 UNUSED_PARAM(callFrame);
26920 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
26921 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26922 if (!shouldAllowAccess)
26923 return JSValue::encode(jsUndefined());
26924 auto& impl = castedThis->wrapped();
26925 if (UNLIKELY(callFrame->argumentCount() < 2))
26926 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
26927 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
26928 auto scope = convert<IDLInterface<Node>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "scope", "Window", "matchingElementInFlatTree", "Node"); });
26929 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
26930 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
26931 auto selectors = convert<IDLDOMString>(*lexicalGlobalObject, argument1.value());
26932 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
26933 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLNullable<IDLInterface<Element>>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.matchingElementInFlatTree(*scope, WTFMove(selectors)))));
26934}
26935
26936JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_matchingElementInFlatTree, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
26937{
26938 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_matchingElementInFlatTreeBody>(*lexicalGlobalObject, *callFrame, "matchingElementInFlatTree");
26939}
26940
26941static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_requestAnimationFrameBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
26942{
26943 auto& vm = JSC::getVM(lexicalGlobalObject);
26944 auto throwScope = DECLARE_THROW_SCOPE(vm);
26945 UNUSED_PARAM(throwScope);
26946 UNUSED_PARAM(callFrame);
26947 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
26948 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26949 if (!shouldAllowAccess)
26950 return JSValue::encode(jsUndefined());
26951 auto& impl = castedThis->wrapped();
26952 if (UNLIKELY(callFrame->argumentCount() < 1))
26953 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
26954 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
26955 auto callback = convert<IDLCallbackFunction<JSRequestAnimationFrameCallback>>(*lexicalGlobalObject, argument0.value(), *castedThis->globalObject(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeFunctionError(lexicalGlobalObject, scope, 0, "callback", "Window", "requestAnimationFrame"); });
26956 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
26957 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.requestAnimationFrame(callback.releaseNonNull()))));
26958}
26959
26960JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_requestAnimationFrame, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
26961{
26962 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_requestAnimationFrameBody>(*lexicalGlobalObject, *callFrame, "requestAnimationFrame");
26963}
26964
26965static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_cancelAnimationFrameBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
26966{
26967 auto& vm = JSC::getVM(lexicalGlobalObject);
26968 auto throwScope = DECLARE_THROW_SCOPE(vm);
26969 UNUSED_PARAM(throwScope);
26970 UNUSED_PARAM(callFrame);
26971 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
26972 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26973 if (!shouldAllowAccess)
26974 return JSValue::encode(jsUndefined());
26975 auto& impl = castedThis->wrapped();
26976 if (UNLIKELY(callFrame->argumentCount() < 1))
26977 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
26978 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
26979 auto handle = convert<IDLUnsignedLong>(*lexicalGlobalObject, argument0.value());
26980 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
26981 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.cancelAnimationFrame(WTFMove(handle)); })));
26982}
26983
26984JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_cancelAnimationFrame, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
26985{
26986 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_cancelAnimationFrameBody>(*lexicalGlobalObject, *callFrame, "cancelAnimationFrame");
26987}
26988
26989static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_getComputedStyleBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
26990{
26991 auto& vm = JSC::getVM(lexicalGlobalObject);
26992 auto throwScope = DECLARE_THROW_SCOPE(vm);
26993 UNUSED_PARAM(throwScope);
26994 UNUSED_PARAM(callFrame);
26995 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
26996 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
26997 if (!shouldAllowAccess)
26998 return JSValue::encode(jsUndefined());
26999 auto& impl = castedThis->wrapped();
27000 if (UNLIKELY(callFrame->argumentCount() < 1))
27001 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
27002 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
27003 auto element = convert<IDLInterface<Element>>(*lexicalGlobalObject, argument0.value(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentTypeError(lexicalGlobalObject, scope, 0, "element", "Window", "getComputedStyle", "Element"); });
27004 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27005 EnsureStillAliveScope argument1 = callFrame->argument(1);
27006 auto pseudoElement = argument1.value().isUndefined() ? String() : convert<IDLNullable<IDLUSVString>>(*lexicalGlobalObject, argument1.value());
27007 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27008 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJSNewlyCreated<IDLInterface<CSSStyleDeclaration>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.getComputedStyle(*element, WTFMove(pseudoElement)))));
27009}
27010
27011JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_getComputedStyle, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
27012{
27013 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_getComputedStyleBody>(*lexicalGlobalObject, *callFrame, "getComputedStyle");
27014}
27015
27016static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_matchMediaBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
27017{
27018 auto& vm = JSC::getVM(lexicalGlobalObject);
27019 auto throwScope = DECLARE_THROW_SCOPE(vm);
27020 UNUSED_PARAM(throwScope);
27021 UNUSED_PARAM(callFrame);
27022 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
27023 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
27024 if (!shouldAllowAccess)
27025 return JSValue::encode(jsUndefined());
27026 auto& impl = castedThis->wrapped();
27027 if (UNLIKELY(callFrame->argumentCount() < 1))
27028 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
27029 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
27030 auto query = convert<IDLUSVString>(*lexicalGlobalObject, argument0.value());
27031 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27032 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJSNewlyCreated<IDLInterface<MediaQueryList>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.matchMedia(WTFMove(query)))));
27033}
27034
27035JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_matchMedia, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
27036{
27037 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_matchMediaBody>(*lexicalGlobalObject, *callFrame, "matchMedia");
27038}
27039
27040static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_moveToBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
27041{
27042 auto& vm = JSC::getVM(lexicalGlobalObject);
27043 auto throwScope = DECLARE_THROW_SCOPE(vm);
27044 UNUSED_PARAM(throwScope);
27045 UNUSED_PARAM(callFrame);
27046 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
27047 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
27048 if (!shouldAllowAccess)
27049 return JSValue::encode(jsUndefined());
27050 auto& impl = castedThis->wrapped();
27051 EnsureStillAliveScope argument0 = callFrame->argument(0);
27052 auto x = convert<IDLUnrestrictedFloat>(*lexicalGlobalObject, argument0.value());
27053 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27054 EnsureStillAliveScope argument1 = callFrame->argument(1);
27055 auto y = convert<IDLUnrestrictedFloat>(*lexicalGlobalObject, argument1.value());
27056 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27057 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.moveTo(WTFMove(x), WTFMove(y)); })));
27058}
27059
27060JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_moveTo, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
27061{
27062 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_moveToBody>(*lexicalGlobalObject, *callFrame, "moveTo");
27063}
27064
27065static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_moveByBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
27066{
27067 auto& vm = JSC::getVM(lexicalGlobalObject);
27068 auto throwScope = DECLARE_THROW_SCOPE(vm);
27069 UNUSED_PARAM(throwScope);
27070 UNUSED_PARAM(callFrame);
27071 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
27072 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
27073 if (!shouldAllowAccess)
27074 return JSValue::encode(jsUndefined());
27075 auto& impl = castedThis->wrapped();
27076 EnsureStillAliveScope argument0 = callFrame->argument(0);
27077 auto x = convert<IDLUnrestrictedFloat>(*lexicalGlobalObject, argument0.value());
27078 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27079 EnsureStillAliveScope argument1 = callFrame->argument(1);
27080 auto y = convert<IDLUnrestrictedFloat>(*lexicalGlobalObject, argument1.value());
27081 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27082 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.moveBy(WTFMove(x), WTFMove(y)); })));
27083}
27084
27085JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_moveBy, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
27086{
27087 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_moveByBody>(*lexicalGlobalObject, *callFrame, "moveBy");
27088}
27089
27090static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_resizeToBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
27091{
27092 auto& vm = JSC::getVM(lexicalGlobalObject);
27093 auto throwScope = DECLARE_THROW_SCOPE(vm);
27094 UNUSED_PARAM(throwScope);
27095 UNUSED_PARAM(callFrame);
27096 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
27097 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
27098 if (!shouldAllowAccess)
27099 return JSValue::encode(jsUndefined());
27100 auto& impl = castedThis->wrapped();
27101 EnsureStillAliveScope argument0 = callFrame->argument(0);
27102 auto width = convert<IDLUnrestrictedFloat>(*lexicalGlobalObject, argument0.value());
27103 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27104 EnsureStillAliveScope argument1 = callFrame->argument(1);
27105 auto height = convert<IDLUnrestrictedFloat>(*lexicalGlobalObject, argument1.value());
27106 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27107 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.resizeTo(WTFMove(width), WTFMove(height)); })));
27108}
27109
27110JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_resizeTo, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
27111{
27112 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_resizeToBody>(*lexicalGlobalObject, *callFrame, "resizeTo");
27113}
27114
27115static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_resizeByBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
27116{
27117 auto& vm = JSC::getVM(lexicalGlobalObject);
27118 auto throwScope = DECLARE_THROW_SCOPE(vm);
27119 UNUSED_PARAM(throwScope);
27120 UNUSED_PARAM(callFrame);
27121 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
27122 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
27123 if (!shouldAllowAccess)
27124 return JSValue::encode(jsUndefined());
27125 auto& impl = castedThis->wrapped();
27126 EnsureStillAliveScope argument0 = callFrame->argument(0);
27127 auto x = convert<IDLUnrestrictedFloat>(*lexicalGlobalObject, argument0.value());
27128 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27129 EnsureStillAliveScope argument1 = callFrame->argument(1);
27130 auto y = convert<IDLUnrestrictedFloat>(*lexicalGlobalObject, argument1.value());
27131 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27132 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.resizeBy(WTFMove(x), WTFMove(y)); })));
27133}
27134
27135JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_resizeBy, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
27136{
27137 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_resizeByBody>(*lexicalGlobalObject, *callFrame, "resizeBy");
27138}
27139
27140static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_scroll1Body(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
27141{
27142 auto& vm = JSC::getVM(lexicalGlobalObject);
27143 auto throwScope = DECLARE_THROW_SCOPE(vm);
27144 UNUSED_PARAM(throwScope);
27145 UNUSED_PARAM(callFrame);
27146 auto& impl = castedThis->wrapped();
27147 EnsureStillAliveScope argument0 = callFrame->argument(0);
27148 auto options = convert<IDLDictionary<ScrollToOptions>>(*lexicalGlobalObject, argument0.value());
27149 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27150 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.scrollTo(WTFMove(options)); })));
27151}
27152
27153static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_scroll2Body(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
27154{
27155 auto& vm = JSC::getVM(lexicalGlobalObject);
27156 auto throwScope = DECLARE_THROW_SCOPE(vm);
27157 UNUSED_PARAM(throwScope);
27158 UNUSED_PARAM(callFrame);
27159 auto& impl = castedThis->wrapped();
27160 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
27161 auto x = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument0.value());
27162 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27163 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
27164 auto y = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument1.value());
27165 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27166 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.scrollTo(WTFMove(x), WTFMove(y)); })));
27167}
27168
27169static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_scrollOverloadDispatcher(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
27170{
27171 auto& vm = JSC::getVM(lexicalGlobalObject);
27172 auto throwScope = DECLARE_THROW_SCOPE(vm);
27173 UNUSED_PARAM(throwScope);
27174 UNUSED_PARAM(callFrame);
27175 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
27176 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
27177 if (!shouldAllowAccess)
27178 return JSValue::encode(jsUndefined());
27179 size_t argsCount = std::min<size_t>(2, callFrame->argumentCount());
27180 if (argsCount == 0) {
27181 RELEASE_AND_RETURN(throwScope, (jsDOMWindowInstanceFunction_scroll1Body(lexicalGlobalObject, callFrame, castedThis)));
27182 }
27183 if (argsCount == 1) {
27184 RELEASE_AND_RETURN(throwScope, (jsDOMWindowInstanceFunction_scroll1Body(lexicalGlobalObject, callFrame, castedThis)));
27185 }
27186 if (argsCount == 2) {
27187 RELEASE_AND_RETURN(throwScope, (jsDOMWindowInstanceFunction_scroll2Body(lexicalGlobalObject, callFrame, castedThis)));
27188 }
27189 return throwVMTypeError(lexicalGlobalObject, throwScope);
27190}
27191
27192JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_scroll, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
27193{
27194 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_scrollOverloadDispatcher>(*lexicalGlobalObject, *callFrame, "scroll");
27195}
27196
27197static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_scrollTo1Body(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
27198{
27199 auto& vm = JSC::getVM(lexicalGlobalObject);
27200 auto throwScope = DECLARE_THROW_SCOPE(vm);
27201 UNUSED_PARAM(throwScope);
27202 UNUSED_PARAM(callFrame);
27203 auto& impl = castedThis->wrapped();
27204 EnsureStillAliveScope argument0 = callFrame->argument(0);
27205 auto options = convert<IDLDictionary<ScrollToOptions>>(*lexicalGlobalObject, argument0.value());
27206 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27207 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.scrollTo(WTFMove(options)); })));
27208}
27209
27210static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_scrollTo2Body(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
27211{
27212 auto& vm = JSC::getVM(lexicalGlobalObject);
27213 auto throwScope = DECLARE_THROW_SCOPE(vm);
27214 UNUSED_PARAM(throwScope);
27215 UNUSED_PARAM(callFrame);
27216 auto& impl = castedThis->wrapped();
27217 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
27218 auto x = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument0.value());
27219 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27220 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
27221 auto y = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument1.value());
27222 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27223 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.scrollTo(WTFMove(x), WTFMove(y)); })));
27224}
27225
27226static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_scrollToOverloadDispatcher(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
27227{
27228 auto& vm = JSC::getVM(lexicalGlobalObject);
27229 auto throwScope = DECLARE_THROW_SCOPE(vm);
27230 UNUSED_PARAM(throwScope);
27231 UNUSED_PARAM(callFrame);
27232 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
27233 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
27234 if (!shouldAllowAccess)
27235 return JSValue::encode(jsUndefined());
27236 size_t argsCount = std::min<size_t>(2, callFrame->argumentCount());
27237 if (argsCount == 0) {
27238 RELEASE_AND_RETURN(throwScope, (jsDOMWindowInstanceFunction_scrollTo1Body(lexicalGlobalObject, callFrame, castedThis)));
27239 }
27240 if (argsCount == 1) {
27241 RELEASE_AND_RETURN(throwScope, (jsDOMWindowInstanceFunction_scrollTo1Body(lexicalGlobalObject, callFrame, castedThis)));
27242 }
27243 if (argsCount == 2) {
27244 RELEASE_AND_RETURN(throwScope, (jsDOMWindowInstanceFunction_scrollTo2Body(lexicalGlobalObject, callFrame, castedThis)));
27245 }
27246 return throwVMTypeError(lexicalGlobalObject, throwScope);
27247}
27248
27249JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_scrollTo, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
27250{
27251 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_scrollToOverloadDispatcher>(*lexicalGlobalObject, *callFrame, "scrollTo");
27252}
27253
27254static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_scrollBy1Body(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
27255{
27256 auto& vm = JSC::getVM(lexicalGlobalObject);
27257 auto throwScope = DECLARE_THROW_SCOPE(vm);
27258 UNUSED_PARAM(throwScope);
27259 UNUSED_PARAM(callFrame);
27260 auto& impl = castedThis->wrapped();
27261 EnsureStillAliveScope argument0 = callFrame->argument(0);
27262 auto option = convert<IDLDictionary<ScrollToOptions>>(*lexicalGlobalObject, argument0.value());
27263 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27264 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.scrollBy(WTFMove(option)); })));
27265}
27266
27267static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_scrollBy2Body(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
27268{
27269 auto& vm = JSC::getVM(lexicalGlobalObject);
27270 auto throwScope = DECLARE_THROW_SCOPE(vm);
27271 UNUSED_PARAM(throwScope);
27272 UNUSED_PARAM(callFrame);
27273 auto& impl = castedThis->wrapped();
27274 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
27275 auto x = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument0.value());
27276 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27277 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
27278 auto y = convert<IDLUnrestrictedDouble>(*lexicalGlobalObject, argument1.value());
27279 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27280 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.scrollBy(WTFMove(x), WTFMove(y)); })));
27281}
27282
27283static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_scrollByOverloadDispatcher(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
27284{
27285 auto& vm = JSC::getVM(lexicalGlobalObject);
27286 auto throwScope = DECLARE_THROW_SCOPE(vm);
27287 UNUSED_PARAM(throwScope);
27288 UNUSED_PARAM(callFrame);
27289 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
27290 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
27291 if (!shouldAllowAccess)
27292 return JSValue::encode(jsUndefined());
27293 size_t argsCount = std::min<size_t>(2, callFrame->argumentCount());
27294 if (argsCount == 0) {
27295 RELEASE_AND_RETURN(throwScope, (jsDOMWindowInstanceFunction_scrollBy1Body(lexicalGlobalObject, callFrame, castedThis)));
27296 }
27297 if (argsCount == 1) {
27298 RELEASE_AND_RETURN(throwScope, (jsDOMWindowInstanceFunction_scrollBy1Body(lexicalGlobalObject, callFrame, castedThis)));
27299 }
27300 if (argsCount == 2) {
27301 RELEASE_AND_RETURN(throwScope, (jsDOMWindowInstanceFunction_scrollBy2Body(lexicalGlobalObject, callFrame, castedThis)));
27302 }
27303 return throwVMTypeError(lexicalGlobalObject, throwScope);
27304}
27305
27306JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_scrollBy, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
27307{
27308 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_scrollByOverloadDispatcher>(*lexicalGlobalObject, *callFrame, "scrollBy");
27309}
27310
27311static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_requestIdleCallbackBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
27312{
27313 auto& vm = JSC::getVM(lexicalGlobalObject);
27314 auto throwScope = DECLARE_THROW_SCOPE(vm);
27315 UNUSED_PARAM(throwScope);
27316 UNUSED_PARAM(callFrame);
27317 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
27318 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
27319 if (!shouldAllowAccess)
27320 return JSValue::encode(jsUndefined());
27321 auto& impl = castedThis->wrapped();
27322 if (UNLIKELY(callFrame->argumentCount() < 1))
27323 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
27324 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
27325 auto callback = convert<IDLCallbackFunction<JSIdleRequestCallback>>(*lexicalGlobalObject, argument0.value(), *castedThis->globalObject(), [](JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope) { throwArgumentMustBeFunctionError(lexicalGlobalObject, scope, 0, "callback", "Window", "requestIdleCallback"); });
27326 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27327 EnsureStillAliveScope argument1 = callFrame->argument(1);
27328 auto options = convert<IDLDictionary<IdleRequestOptions>>(*lexicalGlobalObject, argument1.value());
27329 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27330 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUnsignedLong>(*lexicalGlobalObject, throwScope, impl.requestIdleCallback(callback.releaseNonNull(), WTFMove(options)))));
27331}
27332
27333JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_requestIdleCallback, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
27334{
27335 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_requestIdleCallbackBody>(*lexicalGlobalObject, *callFrame, "requestIdleCallback");
27336}
27337
27338static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_cancelIdleCallbackBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
27339{
27340 auto& vm = JSC::getVM(lexicalGlobalObject);
27341 auto throwScope = DECLARE_THROW_SCOPE(vm);
27342 UNUSED_PARAM(throwScope);
27343 UNUSED_PARAM(callFrame);
27344 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
27345 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
27346 if (!shouldAllowAccess)
27347 return JSValue::encode(jsUndefined());
27348 auto& impl = castedThis->wrapped();
27349 if (UNLIKELY(callFrame->argumentCount() < 1))
27350 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
27351 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
27352 auto handle = convert<IDLUnsignedLong>(*lexicalGlobalObject, argument0.value());
27353 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27354 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.cancelIdleCallback(WTFMove(handle)); })));
27355}
27356
27357JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_cancelIdleCallback, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
27358{
27359 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_cancelIdleCallbackBody>(*lexicalGlobalObject, *callFrame, "cancelIdleCallback");
27360}
27361
27362static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_getSelectionBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
27363{
27364 auto& vm = JSC::getVM(lexicalGlobalObject);
27365 auto throwScope = DECLARE_THROW_SCOPE(vm);
27366 UNUSED_PARAM(throwScope);
27367 UNUSED_PARAM(callFrame);
27368 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
27369 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
27370 if (!shouldAllowAccess)
27371 return JSValue::encode(jsUndefined());
27372 auto& impl = castedThis->wrapped();
27373 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLNullable<IDLInterface<DOMSelection>>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, impl.getSelection())));
27374}
27375
27376JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_getSelection, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
27377{
27378 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_getSelectionBody>(*lexicalGlobalObject, *callFrame, "getSelection");
27379}
27380
27381static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_atobBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
27382{
27383 auto& vm = JSC::getVM(lexicalGlobalObject);
27384 auto throwScope = DECLARE_THROW_SCOPE(vm);
27385 UNUSED_PARAM(throwScope);
27386 UNUSED_PARAM(callFrame);
27387 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
27388 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
27389 if (!shouldAllowAccess)
27390 return JSValue::encode(jsUndefined());
27391 auto& impl = castedThis->wrapped();
27392 if (UNLIKELY(callFrame->argumentCount() < 1))
27393 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
27394 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
27395 auto string = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
27396 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27397 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.atob(WTFMove(string)))));
27398}
27399
27400JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_atob, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
27401{
27402 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_atobBody>(*lexicalGlobalObject, *callFrame, "atob");
27403}
27404
27405static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_btoaBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
27406{
27407 auto& vm = JSC::getVM(lexicalGlobalObject);
27408 auto throwScope = DECLARE_THROW_SCOPE(vm);
27409 UNUSED_PARAM(throwScope);
27410 UNUSED_PARAM(callFrame);
27411 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
27412 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
27413 if (!shouldAllowAccess)
27414 return JSValue::encode(jsUndefined());
27415 auto& impl = castedThis->wrapped();
27416 if (UNLIKELY(callFrame->argumentCount() < 1))
27417 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
27418 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
27419 auto string = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
27420 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27421 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLDOMString>(*lexicalGlobalObject, throwScope, impl.btoa(WTFMove(string)))));
27422}
27423
27424JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_btoa, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
27425{
27426 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_btoaBody>(*lexicalGlobalObject, *callFrame, "btoa");
27427}
27428
27429static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_setTimeoutBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
27430{
27431 auto& vm = JSC::getVM(lexicalGlobalObject);
27432 auto throwScope = DECLARE_THROW_SCOPE(vm);
27433 UNUSED_PARAM(throwScope);
27434 UNUSED_PARAM(callFrame);
27435 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
27436 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
27437 if (!shouldAllowAccess)
27438 return JSValue::encode(jsUndefined());
27439 auto& impl = castedThis->wrapped();
27440 if (UNLIKELY(callFrame->argumentCount() < 1))
27441 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
27442 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
27443 auto handler = convert<IDLScheduledAction>(*lexicalGlobalObject, argument0.value(), *castedThis->globalObject());
27444 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27445 EnsureStillAliveScope argument1 = callFrame->argument(1);
27446 auto timeout = convert<IDLLong>(*lexicalGlobalObject, argument1.value());
27447 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27448 auto arguments = convertVariadicArguments<IDLAny>(*lexicalGlobalObject, *callFrame, 2);
27449 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27450 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLLong>(*lexicalGlobalObject, throwScope, impl.setTimeout(*jsCast<JSDOMGlobalObject*>(lexicalGlobalObject), WTFMove(handler), WTFMove(timeout), WTFMove(arguments)))));
27451}
27452
27453JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_setTimeout, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
27454{
27455 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_setTimeoutBody>(*lexicalGlobalObject, *callFrame, "setTimeout");
27456}
27457
27458static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_clearTimeoutBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
27459{
27460 auto& vm = JSC::getVM(lexicalGlobalObject);
27461 auto throwScope = DECLARE_THROW_SCOPE(vm);
27462 UNUSED_PARAM(throwScope);
27463 UNUSED_PARAM(callFrame);
27464 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
27465 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
27466 if (!shouldAllowAccess)
27467 return JSValue::encode(jsUndefined());
27468 auto& impl = castedThis->wrapped();
27469 EnsureStillAliveScope argument0 = callFrame->argument(0);
27470 auto handle = convert<IDLLong>(*lexicalGlobalObject, argument0.value());
27471 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27472 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.clearTimeout(WTFMove(handle)); })));
27473}
27474
27475JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_clearTimeout, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
27476{
27477 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_clearTimeoutBody>(*lexicalGlobalObject, *callFrame, "clearTimeout");
27478}
27479
27480static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_setIntervalBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
27481{
27482 auto& vm = JSC::getVM(lexicalGlobalObject);
27483 auto throwScope = DECLARE_THROW_SCOPE(vm);
27484 UNUSED_PARAM(throwScope);
27485 UNUSED_PARAM(callFrame);
27486 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
27487 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
27488 if (!shouldAllowAccess)
27489 return JSValue::encode(jsUndefined());
27490 auto& impl = castedThis->wrapped();
27491 if (UNLIKELY(callFrame->argumentCount() < 1))
27492 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
27493 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
27494 auto handler = convert<IDLScheduledAction>(*lexicalGlobalObject, argument0.value(), *castedThis->globalObject());
27495 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27496 EnsureStillAliveScope argument1 = callFrame->argument(1);
27497 auto timeout = convert<IDLLong>(*lexicalGlobalObject, argument1.value());
27498 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27499 auto arguments = convertVariadicArguments<IDLAny>(*lexicalGlobalObject, *callFrame, 2);
27500 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27501 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLLong>(*lexicalGlobalObject, throwScope, impl.setInterval(*jsCast<JSDOMGlobalObject*>(lexicalGlobalObject), WTFMove(handler), WTFMove(timeout), WTFMove(arguments)))));
27502}
27503
27504JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_setInterval, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
27505{
27506 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_setIntervalBody>(*lexicalGlobalObject, *callFrame, "setInterval");
27507}
27508
27509static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_clearIntervalBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
27510{
27511 auto& vm = JSC::getVM(lexicalGlobalObject);
27512 auto throwScope = DECLARE_THROW_SCOPE(vm);
27513 UNUSED_PARAM(throwScope);
27514 UNUSED_PARAM(callFrame);
27515 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
27516 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
27517 if (!shouldAllowAccess)
27518 return JSValue::encode(jsUndefined());
27519 auto& impl = castedThis->wrapped();
27520 EnsureStillAliveScope argument0 = callFrame->argument(0);
27521 auto handle = convert<IDLLong>(*lexicalGlobalObject, argument0.value());
27522 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27523 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.clearInterval(WTFMove(handle)); })));
27524}
27525
27526JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_clearInterval, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
27527{
27528 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_clearIntervalBody>(*lexicalGlobalObject, *callFrame, "clearInterval");
27529}
27530
27531static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_queueMicrotaskBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSDOMWindow>::ClassParameter castedThis)
27532{
27533 auto& vm = JSC::getVM(lexicalGlobalObject);
27534 auto throwScope = DECLARE_THROW_SCOPE(vm);
27535 UNUSED_PARAM(throwScope);
27536 UNUSED_PARAM(callFrame);
27537 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
27538 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
27539 if (!shouldAllowAccess)
27540 return JSValue::encode(jsUndefined());
27541 RELEASE_AND_RETURN(throwScope, (JSValue::encode(castedThis->queueMicrotask(*lexicalGlobalObject, *callFrame))));
27542}
27543
27544JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_queueMicrotask, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
27545{
27546 return IDLOperation<JSDOMWindow>::call<jsDOMWindowInstanceFunction_queueMicrotaskBody>(*lexicalGlobalObject, *callFrame, "queueMicrotask");
27547}
27548
27549static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_createImageBitmap1Body(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperationReturningPromise<JSDOMWindow>::ClassParameter castedThis, Ref<DeferredPromise>&& promise)
27550{
27551 auto& vm = JSC::getVM(lexicalGlobalObject);
27552 auto throwScope = DECLARE_THROW_SCOPE(vm);
27553 UNUSED_PARAM(throwScope);
27554 UNUSED_PARAM(callFrame);
27555 auto& impl = castedThis->wrapped();
27556 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
27557 auto image = convert<IDLUnion<IDLInterface<HTMLImageElement>, IDLInterface<HTMLVideoElement>, IDLInterface<HTMLCanvasElement>, IDLInterface<ImageBitmap>, IDLInterface<TypedOMCSSImageValue>, IDLInterface<Blob>, IDLInterface<ImageData>>>(*lexicalGlobalObject, argument0.value());
27558 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27559 EnsureStillAliveScope argument1 = callFrame->argument(1);
27560 auto options = convert<IDLDictionary<ImageBitmapOptions>>(*lexicalGlobalObject, argument1.value());
27561 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27562 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLPromise<IDLInterface<ImageBitmap>>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, [&]() -> decltype(auto) { return impl.createImageBitmap(WTFMove(image), WTFMove(options), WTFMove(promise)); })));
27563}
27564
27565static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_createImageBitmap2Body(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperationReturningPromise<JSDOMWindow>::ClassParameter castedThis, Ref<DeferredPromise>&& promise)
27566{
27567 auto& vm = JSC::getVM(lexicalGlobalObject);
27568 auto throwScope = DECLARE_THROW_SCOPE(vm);
27569 UNUSED_PARAM(throwScope);
27570 UNUSED_PARAM(callFrame);
27571 auto& impl = castedThis->wrapped();
27572 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
27573 auto image = convert<IDLUnion<IDLInterface<HTMLImageElement>, IDLInterface<HTMLVideoElement>, IDLInterface<HTMLCanvasElement>, IDLInterface<ImageBitmap>, IDLInterface<TypedOMCSSImageValue>, IDLInterface<Blob>, IDLInterface<ImageData>>>(*lexicalGlobalObject, argument0.value());
27574 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27575 EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
27576 auto sx = convert<IDLLong>(*lexicalGlobalObject, argument1.value());
27577 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27578 EnsureStillAliveScope argument2 = callFrame->uncheckedArgument(2);
27579 auto sy = convert<IDLLong>(*lexicalGlobalObject, argument2.value());
27580 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27581 EnsureStillAliveScope argument3 = callFrame->uncheckedArgument(3);
27582 auto sw = convert<IDLLong>(*lexicalGlobalObject, argument3.value());
27583 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27584 EnsureStillAliveScope argument4 = callFrame->uncheckedArgument(4);
27585 auto sh = convert<IDLLong>(*lexicalGlobalObject, argument4.value());
27586 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27587 EnsureStillAliveScope argument5 = callFrame->argument(5);
27588 auto options = convert<IDLDictionary<ImageBitmapOptions>>(*lexicalGlobalObject, argument5.value());
27589 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27590 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLPromise<IDLInterface<ImageBitmap>>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, [&]() -> decltype(auto) { return impl.createImageBitmap(WTFMove(image), WTFMove(sx), WTFMove(sy), WTFMove(sw), WTFMove(sh), WTFMove(options), WTFMove(promise)); })));
27591}
27592
27593static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_createImageBitmapOverloadDispatcher(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperationReturningPromise<JSDOMWindow>::ClassParameter castedThis, Ref<DeferredPromise>&& promise)
27594{
27595 auto& vm = JSC::getVM(lexicalGlobalObject);
27596 auto throwScope = DECLARE_THROW_SCOPE(vm);
27597 UNUSED_PARAM(throwScope);
27598 UNUSED_PARAM(callFrame);
27599 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
27600 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
27601 if (!shouldAllowAccess)
27602 return JSValue::encode(jsUndefined());
27603 size_t argsCount = std::min<size_t>(6, callFrame->argumentCount());
27604 if (argsCount == 1) {
27605 RELEASE_AND_RETURN(throwScope, (jsDOMWindowInstanceFunction_createImageBitmap1Body(lexicalGlobalObject, callFrame, castedThis, WTFMove(promise))));
27606 }
27607 if (argsCount == 2) {
27608 RELEASE_AND_RETURN(throwScope, (jsDOMWindowInstanceFunction_createImageBitmap1Body(lexicalGlobalObject, callFrame, castedThis, WTFMove(promise))));
27609 }
27610 if (argsCount == 5) {
27611 RELEASE_AND_RETURN(throwScope, (jsDOMWindowInstanceFunction_createImageBitmap2Body(lexicalGlobalObject, callFrame, castedThis, WTFMove(promise))));
27612 }
27613 if (argsCount == 6) {
27614 RELEASE_AND_RETURN(throwScope, (jsDOMWindowInstanceFunction_createImageBitmap2Body(lexicalGlobalObject, callFrame, castedThis, WTFMove(promise))));
27615 }
27616 return argsCount < 1 ? throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject)) : throwVMTypeError(lexicalGlobalObject, throwScope);
27617}
27618
27619JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_createImageBitmap, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
27620{
27621 return IDLOperationReturningPromise<JSDOMWindow>::call<jsDOMWindowInstanceFunction_createImageBitmapOverloadDispatcher>(*lexicalGlobalObject, *callFrame, "createImageBitmap");
27622}
27623
27624static inline JSC::EncodedJSValue jsDOMWindowInstanceFunction_fetchBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperationReturningPromise<JSDOMWindow>::ClassParameter castedThis, Ref<DeferredPromise>&& promise)
27625{
27626 auto& vm = JSC::getVM(lexicalGlobalObject);
27627 auto throwScope = DECLARE_THROW_SCOPE(vm);
27628 UNUSED_PARAM(throwScope);
27629 UNUSED_PARAM(callFrame);
27630 bool shouldAllowAccess = BindingSecurity::shouldAllowAccessToDOMWindow(lexicalGlobalObject, *castedThis, ThrowSecurityError);
27631 EXCEPTION_ASSERT_UNUSED(throwScope, !throwScope.exception() || !shouldAllowAccess);
27632 if (!shouldAllowAccess)
27633 return JSValue::encode(jsUndefined());
27634 auto& impl = castedThis->wrapped();
27635 if (UNLIKELY(callFrame->argumentCount() < 1))
27636 return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
27637 EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
27638 auto input = convert<IDLUnion<IDLInterface<FetchRequest>, IDLUSVString>>(*lexicalGlobalObject, argument0.value());
27639 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27640 EnsureStillAliveScope argument1 = callFrame->argument(1);
27641 auto init = convert<IDLDictionary<FetchRequestInit>>(*lexicalGlobalObject, argument1.value());
27642 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
27643 RELEASE_AND_RETURN(throwScope, JSValue::encode(toJSNewlyCreated<IDLPromise<IDLInterface<FetchResponse>>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, [&]() -> decltype(auto) { return WebCore::WindowOrWorkerGlobalScopeFetch::fetch(impl, WTFMove(input), WTFMove(init), WTFMove(promise)); })));
27644}
27645
27646JSC_DEFINE_HOST_FUNCTION(jsDOMWindowInstanceFunction_fetch, (JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame))
27647{
27648 return IDLOperationReturningPromise<JSDOMWindow>::call<jsDOMWindowInstanceFunction_fetchBody>(*lexicalGlobalObject, *callFrame, "fetch");
27649}
27650
27651JSC::IsoSubspace* JSDOMWindow::subspaceForImpl(JSC::VM& vm)
27652{
27653 auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
27654 auto& spaces = clientData.subspaces();
27655 if (auto* space = spaces.m_subspaceForDOMWindow.get())
27656 return space;
27657 spaces.m_subspaceForDOMWindow = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, clientData.m_heapCellTypeForJSDOMWindow.get(), JSDOMWindow);
27658 auto* space = spaces.m_subspaceForDOMWindow.get();
27659IGNORE_WARNINGS_BEGIN("unreachable-code")
27660IGNORE_WARNINGS_BEGIN("tautological-compare")
27661 void (*myVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSDOMWindow::visitOutputConstraints;
27662 void (*jsCellVisitOutputConstraint)(JSC::JSCell*, JSC::SlotVisitor&) = JSC::JSCell::visitOutputConstraints;
27663 if (myVisitOutputConstraint != jsCellVisitOutputConstraint)
27664 clientData.outputConstraintSpaces().append(space);
27665IGNORE_WARNINGS_END
27666IGNORE_WARNINGS_END
27667 return space;
27668}
27669
27670template<typename Visitor>
27671void JSDOMWindow::visitChildrenImpl(JSCell* cell, Visitor& visitor)
27672{
27673 auto* thisObject = jsCast<JSDOMWindow*>(cell);
27674 ASSERT_GC_OBJECT_INHERITS(thisObject, info());
27675 Base::visitChildren(thisObject, visitor);
27676 thisObject->visitAdditionalChildren(visitor);
27677}
27678
27679DEFINE_VISIT_CHILDREN(JSDOMWindow);
27680
27681template<typename Visitor>
27682void JSDOMWindow::visitOutputConstraints(JSCell* cell, Visitor& visitor)
27683{
27684 auto* thisObject = jsCast<JSDOMWindow*>(cell);
27685 ASSERT_GC_OBJECT_INHERITS(thisObject, info());
27686 Base::visitOutputConstraints(thisObject, visitor);
27687 thisObject->visitAdditionalChildren(visitor);
27688}
27689
27690template void JSDOMWindow::visitOutputConstraints(JSCell*, AbstractSlotVisitor&);
27691template void JSDOMWindow::visitOutputConstraints(JSCell*, SlotVisitor&);
27692
27693}
27694